Final Class Yiisoft\Validator\Helper\ObjectParser

                public function __construct(
    /**
     * @var object|string A source for parsing rules and data. Can be either a class name string or an
     * instance.
     *
     * @psalm-var class-string|object
     */
    private readonly string|object $source,
    /**
     * @var int Visibility levels the parsed properties must have. For example: public and protected only, this
     * means that the rest (private ones) will be skipped. Defaults to all visibility levels (public, protected and
     * private).
     *
     * @psalm-var int-mask-of<ReflectionProperty::IS_*>
     */
    private readonly int $propertyVisibility = ReflectionProperty::IS_PRIVATE
    | ReflectionProperty::IS_PROTECTED
    | ReflectionProperty::IS_PUBLIC,
    /**
     * @var bool Whether the properties with "static" modifier must be skipped.
     */
    private readonly bool $skipStaticProperties = false,
    /**
     * @var bool Whether some results of parsing (Reflection of a class / an object with properties and rules) must
     * be cached.
     */
    bool $useCache = true,
) {
    /** @var object|string $source */
    if (is_string($source) && !class_exists($source)) {
        throw new InvalidArgumentException(
            sprintf('Class "%s" not found.', $source),
        );
    }
    if ($useCache) {
        $this->cacheKey = (is_object($source) ? $source::class : $source)
            . '_' . $this->propertyVisibility
            . '_' . (int) $this->skipStaticProperties;
    }
}

            

                public function getData(): array
{
    if (!is_object($this->source)) {
        return [];
    }
    $data = [];
    foreach ($this->getReflectionProperties() as $name => $property) {
        if (!$property->isInitialized($this->source)) {
            continue;
        }
        /** @var mixed */
        $data[$name] = $property->getValue($this->source);
    }
    return $data;
}

            

                public function getLabels(): array
{
    if ($this->hasCacheItem('labels')) {
        /** @var array<string, string> */
        return $this->getCacheItem('labels');
    }
    $labels = [];
    foreach ($this->getReflectionProperties() as $property) {
        $attributes = $property->getAttributes(Label::class, ReflectionAttribute::IS_INSTANCEOF);
        foreach ($attributes as $attribute) {
            /** @var Label $instance */
            $instance = $attribute->newInstance();
            $labels[$property->getName()] = $instance->getLabel();
        }
    }
    $this->setCacheItem('labels', $labels);
    return $labels;
}

            

                public function getPropertyTranslator(): ?PropertyTranslatorInterface
{
    return $this->source instanceof PropertyTranslatorProviderInterface
        ? $this->source->getPropertyTranslator()
        : null;
}

            

                public function getPropertyValue(string $property): mixed
{
    if (!is_object($this->source)) {
        return null;
    }
    $reflectionProperty = $this->getReflectionProperties()[$property] ?? null;
    if ($reflectionProperty === null || !$reflectionProperty->isInitialized($this->source)) {
        return null;
    }
    return $reflectionProperty->getValue($this->source);
}

            

                public function getReflectionProperties(): array
{
    if ($this->hasCacheItem('reflectionProperties')) {
        /** @var array<string, ReflectionProperty> */
        return $this->getCacheItem('reflectionProperties');
    }
    $reflectionProperties = [];
    foreach ($this->getReflectionSource()->getProperties($this->propertyVisibility) as $property) {
        if ($this->skipStaticProperties && $property->isStatic()) {
            continue;
        }
        $reflectionProperties[$property->getName()] = $property;
    }
    $this->setCacheItem('reflectionProperties', $reflectionProperties);
    return $reflectionProperties;
}

            

                public function getRules(): array
{
    if ($this->hasCacheItem('rules')) {
        /** @var array $rules */
        $rules = $this->getCacheItem('rules');
        return $this->prepareRules($rules);
    }
    $rules = [];
    // Class rules
    $attributes = $this
        ->getReflectionSource()
        ->getAttributes(RuleInterface::class, ReflectionAttribute::IS_INSTANCEOF);
    foreach ($attributes as $attribute) {
        $rules[] = [$attribute->newInstance(), Attribute::TARGET_CLASS];
    }
    // Properties rules
    foreach ($this->getReflectionProperties() as $property) {
        // TODO: use Generator to collect attributes.
        $attributes = $property->getAttributes(RuleInterface::class, ReflectionAttribute::IS_INSTANCEOF);
        foreach ($attributes as $attribute) {
            /** @psalm-suppress UndefinedInterfaceMethod */
            $rules[$property->getName()][] = [$attribute->newInstance(), Attribute::TARGET_PROPERTY];
        }
    }
    $this->setCacheItem('rules', $rules);
    return $this->prepareRules($rules);
}

            

                public function hasProperty(string $property): bool
{
    return is_object($this->source) && array_key_exists($property, $this->getReflectionProperties());
}