Class yii\apidoc\templates\project\ApiRenderer

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        if ($value instanceof Behavior) {
            $this->attachBehavior($name, $value);
        } elseif ($value instanceof \Closure) {
            $this->attachBehavior($name, call_user_func($value));
        } elseif (isset($value['__class']) && is_subclass_of($value['__class'], Behavior::class)) {
            $this->attachBehavior($name, Yii::createObject($value));
        } elseif (!isset($value['__class']) && isset($value['class']) && is_subclass_of($value['class'], Behavior::class)) {
            $this->attachBehavior($name, Yii::createObject($value));
        } elseif (is_string($value) && is_subclass_of($value, Behavior::class, true)) {
            $this->attachBehavior($name, Yii::createObject($value));
        } else {
            throw new InvalidConfigException('Class is not of type ' . Behavior::class . ' or its subclasses');
        }
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function createSubjectLink($subject, $title = null, $options = [], $type = null)
{
    if ($subject instanceof PseudoTypeDoc) {
        $href = $this->generateApiUrl($subject->parent->name) . "#{$subject->type}-type-{$subject->name}";
        return $this->generateLink($subject->name, $href, $options);
    }
    if ($subject instanceof PseudoTypeImportDoc) {
        $typeParentFqsen = (string) $subject->typeParentFqsen;
        $href = $this->generateApiUrl(ltrim($typeParentFqsen, '\\')) . "#{$subject->type}-type-{$subject->typeName}";
        return $this->generateLink($subject->typeName, $href, $options);
    }
    if ($title === null) {
        if ($subject instanceof MethodDoc) {
            $title = $subject->name . '()';
        } else {
            $title = $subject->name;
        }
    }
    if (!$type && property_exists($subject, 'definedBy')) {
        $type = $this->apiContext->getType($subject->definedBy);
    }
    if (!$type) {
        return $subject->name;
    }
    $link = $this->generateApiUrl($type->name) . '#' . $subject->name;
    if ($subject instanceof MethodDoc) {
        $link .= '()';
    }
    $link .= '-detail';
    return $this->generateLink($title, $link, $options);
}

            

                public function createTypeLink(
    $types,
    ?BaseDoc $context = null,
    ?string $title = null,
    array $options = [],
    ?TypeDoc $currentTypeDoc = null
) {
    if ($types === null) {
        return '';
    }
    if (!is_array($types)) {
        $types = [$types];
    } elseif (count($types) > 1) {
        $title = null;
    }
    $links = [];
    foreach ($types as $type) {
        if (is_string($type)) {
            if ($type !== '') {
                $typeDoc = $this->getTypeDocByQualifiedClassName($type, $context);
                if ($typeDoc !== null) {
                    $links[] = $this->createTypeLink($typeDoc, $context, $title, $options);
                    continue;
                }
            }
        } elseif ($type instanceof Type) {
            if ($type instanceof Compound) {
                $innerTypes = TypeHelper::getTypesByAggregatedType($type);
                $links[] = $this->createTypeLink($innerTypes, $context, $title, $options, $currentTypeDoc);
                continue;
            }
            if ($type instanceof ConditionalForParameter || $type instanceof Conditional) {
                $possibleTypes = TypeHelper::getPossibleTypesByConditionalType($type);
                $links[] = $this->createTypeLink($possibleTypes, $context, $title, $options, $currentTypeDoc);
                continue;
            }
            if ($type instanceof Intersection) {
                $innerTypes = TypeHelper::getTypesByAggregatedType($type);
                $innerTypesLinks = array_map(
                    fn (Type $innerType) => $this->createTypeLink($innerType, $context, $title, $options, $currentTypeDoc),
                    $innerTypes,
                );
                $links[] = implode('&', $innerTypesLinks);
                continue;
            }
            if ($type instanceof OffsetAccess) {
                $offsetAccessType = $type->getType();
                if ($offsetAccessType instanceof Object_ && ($offsetAccessTypeFqsen = $offsetAccessType->getFqsen()) !== null) {
                    $templateType = $this->getTemplateType($offsetAccessTypeFqsen->getName(), $context);
                    if ($templateType instanceof Array_) {
                        $links[] = $this->createTypeLink(
                            $templateType->getValueType(),
                            $context,
                            $title,
                            $options,
                            $currentTypeDoc
                        );
                        continue;
                    }
                }
                $typeLink = $this->createTypeLink($offsetAccessType, $context, $title, $options);
                $links[] = $typeLink . '[' . $type->getOffset() . ']';
                continue;
            }
            if ($type instanceof Array_ && str_ends_with((string) $type, '[]')) {
                $valueType = $type->getValueType();
                if ($valueType instanceof Object_ && ($valueTypeFqsen = $valueType->getFqsen()) !== null) {
                    $templateType = $this->getTemplateType($valueTypeFqsen->getName(), $context);
                    if ($templateType !== null) {
                        $typeLink = $this->createTypeLink($templateType, $context, $title, $options, $currentTypeDoc);
                        $links[] = $this->generateLink('array', self::PHPSTAN_TYPE_BASE_URL . 'general-arrays', $options) . "<{$typeLink}>";
                        continue;
                    }
                }
                $links[] = $this->createTypeLink($valueType, $context, $title, $options, $currentTypeDoc) . '[]';
                continue;
            }
            if ($type instanceof ListShape) {
                $itemsLinks = $this->createLinksByShapeItems($type->getItems(), $context, $title, $options, $currentTypeDoc);
                $mainTypeLink = $this->generateLink('list', self::PSALM_TYPE_BASE_URL . 'array_types/#list-shapes', $options);
                $links[] = $mainTypeLink . '{' . implode(', ', $itemsLinks) . '}';
                continue;
            }
            if ($type instanceof ArrayShape) {
                $itemsLinks = $this->createLinksByShapeItems($type->getItems(), $context, $title, $options, $currentTypeDoc);
                $mainTypeLink = $this->generateLink('array', self::PHPSTAN_TYPE_BASE_URL . 'array-shapes', $options);
                $links[] = $mainTypeLink . '{' . implode(', ', $itemsLinks) . '}';
                continue;
            }
            if ($type instanceof ObjectShape) {
                $itemsLinks = $this->createLinksByShapeItems($type->getItems(), $context, $title, $options, $currentTypeDoc);
                $mainTypeLink = $this->generateLink('object', self::PHPSTAN_TYPE_BASE_URL . 'object-shapes', $options);
                $links[] = $mainTypeLink . '{' . implode(', ', $itemsLinks) . '}';
                continue;
            }
            if ($type instanceof Callable_) {
                $links[] = $this->createCallableTypeLink($type, $context, $title, $options, $currentTypeDoc);
                continue;
            }
            if ($type instanceof This && $currentTypeDoc !== null) {
                $links[] = $this->createTypeLink($currentTypeDoc, null, '$this', $options);
                continue;
            }
            if ($type instanceof Static_ && !$type->getGenericTypes() && $currentTypeDoc !== null) {
                $links[] = $this->createTypeLink($currentTypeDoc, null, null, $options);
                continue;
            }
            if ($type instanceof Nullable) {
                $links[] = $this->createTypeLink([$type->getActualType(), new Null_()]);
                continue;
            }
            if (($link = $this->createLinkByTypeWithGenerics($type, $context, $title, $options, $currentTypeDoc)) !== null) {
                $links[] = $link;
                continue;
            }
            if ($type instanceof Object_ && ($typeFqsen = $type->getFqsen()) !== null) {
                $typeName = $typeFqsen->getName();
                if (($typeDoc = $this->getTypeDocByQualifiedClassName((string) $typeFqsen, $context)) !== null) {
                    $links[] = $this->createTypeLink($typeDoc, $context, $typeDoc->name, $options);
                    continue;
                }
                if (($templateType = $this->getTemplateType($typeName, $context)) !== null) {
                    $links[] = $this->createTypeLink($templateType, $context, $title, $options, $currentTypeDoc);
                    continue;
                }
                if (($phpStanType = $this->getPhpStanType($typeName, $context)) !== null) {
                    $links[] = $this->createSubjectLink($phpStanType);
                    continue;
                }
                if (($psalmType = $this->getPsalmType($typeName, $context)) !== null) {
                    $links[] = $this->createSubjectLink($psalmType);
                    continue;
                }
                if (($phpStanTypeImport = $this->getPhpStanTypeImport($typeName, $context)) !== null) {
                    $links[] = $this->createSubjectLink($phpStanTypeImport);
                    continue;
                }
                if (($psalmTypeImport = $this->getPsalmTypeImport($typeName, $context)) !== null) {
                    $links[] = $this->createSubjectLink($psalmTypeImport);
                    continue;
                }
            }
        }
        if (is_object($type) && method_exists($type, '__toString')) {
            $type = (string) $type;
        }
        $link = $this->createTypeLinkByType($type, $title, $options);
        if ($link !== null) {
            $links[] = $link;
        }
    }
    return implode('|', array_unique($links));
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                protected function filterTypes($types, $navClasses)
{
    switch ($navClasses) {
        case 'app':
            $types = array_filter($types, fn ($val) => !str_starts_with((string) $val->name, 'yii\\'));
            break;
        case 'yii':
            $self = $this;
            $types = array_filter($types, function ($val) use ($self) {
                if ($val->name == 'Yii' || $val->name == 'YiiRequirementChecker') {
                    return true;
                }
                if (strlen((string) $val->name) < 5) {
                    return false;
                }
                $subName = substr((string) $val->name, 4, strpos((string) $val->name, '\\', 5) - 4);
                return str_starts_with((string) $val->name, 'yii\\') && !in_array($subName, $self->extensions);
            });
            break;
        default:
            $types = array_filter($types, fn ($val) => str_starts_with((string) $val->name, "yii\\$navClasses\\"));
    }
    return $types;
}

            

                public function generateApiUrl($typeName)
{
    return $this->generateFileName($typeName);
}

            

                protected function generateFileName($typeName)
{
    return strtolower(str_replace('\\', '-', $typeName)) . '.html';
}

            

                public function generateGuideUrl($file)
{
    //skip parsing external url
    if ((str_contains($file, 'https://')) || (str_contains($file, 'http://'))) {
        return $file;
    }
    $hash = '';
    if (($pos = strpos($file, '#')) !== false) {
        $hash = substr($file, $pos);
        $file = substr($file, 0, $pos);
    }
    return rtrim((string) $this->guideUrl, '/') . '/' . $this->guidePrefix . basename($file, '.md') . '.html' . $hash;
}

            

                protected function generateLink($text, $href, $options = [])
{
    $textWithBreaks = str_replace('\\', '\\<wbr>', $text);
    $options['href'] = $href;
    return Html::a($textWithBreaks, null, $options);
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getNavTypes($type, $types)
{
    if ($type === null) {
        return $types;
    }
    return $this->filterTypes($types, $this->getTypeCategory($type));
}

            

                public function getSourceUrl($type, $line = null)
{
    if (is_string($type)) {
        $type = $this->apiContext->getType($type);
    }
    switch ($this->getTypeCategory($type)) {
        case 'yii':
            $baseUrl = 'https://github.com/yiisoft/yii2/blob/master';
            if ($type->name == 'Yii') {
                $url = "$baseUrl/framework/Yii.php";
            } else {
                $url = "$baseUrl/framework/" . str_replace('\\', '/', substr((string) $type->name, 4)) . '.php';
            }
            break;
        case 'app':
            return null;
        default:
            $parts = explode('\\', substr((string) $type->name, 4));
            $ext = $parts[0];
            unset($parts[0]);
            $url = "https://github.com/yiisoft/yii2-$ext/blob/master/" . implode('/', $parts) . '.php';
            break;
    }
    if ($line === null) {
        return $url;
    }
    return $url . '#L' . $line;
}

            

                protected function getTypeCategory($type)
{
    $extensions = $this->extensions;
    $navClasses = 'app';
    if (isset($type)) {
        if ($type->name == 'Yii' || $type->name == 'YiiRequirementChecker') {
            $navClasses = 'yii';
        } elseif (str_starts_with((string) $type->name, 'yii\\')) {
            $navClasses = 'yii';
            $subName = substr((string) $type->name, 4);
            if (($pos = strpos($subName, '\\')) !== false) {
                $subNamespace = substr($subName, 0, $pos);
                if (in_array($subNamespace, $extensions)) {
                    $navClasses = $subNamespace;
                }
            }
        }
    }
    return $navClasses;
}

            

                public function getView()
{
    if ($this->_view === null) {
        $this->_view = new View();
        $assetPath = Yii::getAlias($this->_targetDir) . '/assets';
        if (!is_dir($assetPath)) {
            mkdir($assetPath);
        }
        $this->_view->assetManager = new AssetManager([
            'basePath' => $assetPath,
            'baseUrl' => './assets',
        ]);
    }
    return $this->_view;
}

            

                public function getViewPath()
{
    return Yii::getAlias('@yii/apidoc/templates/html/views');
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
    parent::init();
    $this->pageTitle ??= 'Yii Framework 2.0 API Documentation';
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function renderClasses($names)
{
    $classes = [];
    sort($names, SORT_STRING);
    foreach ($names as $class) {
        if (isset($this->apiContext->classes[$class])) {
            $classes[] = $this->createTypeLink($this->apiContext->classes[$class]);
        } else {
            $classes[] = $this->createTypeLink($class);
        }
    }
    return implode(', ', $classes);
}

            

                public function renderDefaultValue($value)
{
    if ($value === null) {
        return 'null';
    }
    // special numbers which are usually used in octal or hex notation
    static $specials = [
        // file permissions
        '420' => '0644',
        '436' => '0664',
        '438' => '0666',
        '493' => '0755',
        '509' => '0775',
        '511' => '0777',
        // colors used in yii\captcha\CaptchaAction
        '2113696' => '0x2040A0',
        '16777215' => '0xFFFFFF',
    ];
    return $specials[$value] ?? $value;
}

            

                public function renderInheritance($class)
{
    $parents = [];
    $parents[] = $this->createTypeLink($class);
    while ($class->parentClass !== null) {
        if (isset($this->apiContext->classes[$class->parentClass])) {
            $class = $this->apiContext->classes[$class->parentClass];
            $parents[] = $this->createTypeLink($class);
        } else {
            $parents[] = $this->createTypeLink($class->parentClass);
            break;
        }
    }
    return implode(" »\n", $parents);
}

            

                public function renderInterfaces($names)
{
    $interfaces = [];
    sort($names, SORT_STRING);
    foreach ($names as $interface) {
        if (isset($this->apiContext->interfaces[$interface])) {
            $interfaces[] = $this->createTypeLink($this->apiContext->interfaces[$interface]);
        } else {
            $interfaces[] = $this->createTypeLink($interface);
        }
    }
    return implode(', ', $interfaces);
}

            

                public function renderMethodSignature(MethodDoc $method, ?TypeDoc $context = null): string
{
    $params = [];
    foreach ($method->params as $param) {
        $params[] = '<span class="signature-type">' . $this->createTypeLink($param->type, $method) . '</span> '
            . ($param->isPassedByReference ? '<b>&</b>' : '')
            . ApiMarkdown::highlight(
                $param->name
                . ($param->isOptional ? ' = ' . $this->renderDefaultValue($param->defaultValue) : ''),
                'php',
            );
    }
    $definition = [];
    $definition[] = $method->visibility;
    if ($method->isAbstract) {
        $definition[] = 'abstract';
    }
    if ($method->isStatic) {
        $definition[] = 'static';
    }
    return '<span class="signature-defs">' . implode(' ', $definition) . '</span> '
        . $this->createSubjectLink($method, $method->name)
        . str_replace('  ', ' ', '( ' . implode(', ', $params) . ' )')
        . ': <span class="signature-type">' . ($method->isReturnByReference ? '<b>&</b>' : '')
        . $this->createTypeLink($method->returnType, $method, null, [], $context) . '</span>';
}

            

                public function renderPropertySignature($property, $context = null)
{
    if ($property->getter !== null || $property->setter !== null) {
        $sig = [];
        if ($property->getter !== null) {
            $sig[] = $this->renderMethodSignature($property->getter, $context);
        }
        if ($property->setter !== null) {
            $sig[] = $this->renderMethodSignature($property->setter, $context);
        }
        return implode('<br />', $sig);
    }
    $definition = [];
    $definition[] = $property->visibility;
    if ($property->isStatic) {
        $definition[] = 'static';
    }
    return '<span class="signature-defs">' . implode(' ', $definition) . '</span> '
        . '<span class="signature-type">' . $this->createTypeLink($property->type, $property) . '</span>'
        . ' ' . $this->createSubjectLink($property, $property->name) . ' '
        . ApiMarkdown::highlight('= ' . $this->renderDefaultValue($property->defaultValue), 'php');
}

            

                public function renderTraits($names)
{
    $traits = [];
    sort($names, SORT_STRING);
    foreach ($names as $trait) {
        if (isset($this->apiContext->traits[$trait])) {
            $traits[] = $this->createTypeLink($this->apiContext->traits[$trait]);
        } else {
            $traits[] = $this->createTypeLink($trait);
        }
    }
    return implode(', ', $traits);
}

            

                protected function renderWithLayout($viewFile, $params)
{
    $output = $this->getView()->render($viewFile, $params, $this);
    if ($this->layout !== false) {
        $params['content'] = $output;
        return $this->getView()->renderFile($this->layout, $params, $this);
    }
    return $output;
}

            

                public function trigger($name, ?Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}