summaryrefslogtreecommitdiff
path: root/vendor/doctrine/orm/src/Mapping/ReflectionEnumProperty.php
blob: 0ebd978f4125dcf6958ced82fc7964e0f9bb376c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
<?php

declare(strict_types=1);

namespace Doctrine\ORM\Mapping;

use BackedEnum;
use ReflectionProperty;
use ValueError;

use function array_map;
use function is_array;

/** @deprecated use Doctrine\Persistence\Reflection\EnumReflectionProperty instead */
final class ReflectionEnumProperty extends ReflectionProperty
{
    /** @param class-string<BackedEnum> $enumType */
    public function __construct(
        private readonly ReflectionProperty $originalReflectionProperty,
        private readonly string $enumType,
    ) {
        parent::__construct(
            $originalReflectionProperty->class,
            $originalReflectionProperty->name,
        );
    }

    public function getValue(object|null $object = null): int|string|array|null
    {
        if ($object === null) {
            return null;
        }

        $enum = $this->originalReflectionProperty->getValue($object);

        if ($enum === null) {
            return null;
        }

        if (is_array($enum)) {
            return array_map(
                static fn (BackedEnum $item): int|string => $item->value,
                $enum,
            );
        }

        return $enum->value;
    }

    /**
     * @param object                                                 $object
     * @param int|string|int[]|string[]|BackedEnum|BackedEnum[]|null $value
     */
    public function setValue(mixed $object, mixed $value = null): void
    {
        if ($value !== null) {
            if (is_array($value)) {
                $value = array_map(fn (int|string|BackedEnum $item): BackedEnum => $this->initializeEnumValue($object, $item), $value);
            } else {
                $value = $this->initializeEnumValue($object, $value);
            }
        }

        $this->originalReflectionProperty->setValue($object, $value);
    }

    private function initializeEnumValue(object $object, int|string|BackedEnum $value): BackedEnum
    {
        if ($value instanceof BackedEnum) {
            return $value;
        }

        $enumType = $this->enumType;

        try {
            return $enumType::from($value);
        } catch (ValueError $e) {
            throw MappingException::invalidEnumValue(
                $object::class,
                $this->originalReflectionProperty->name,
                (string) $value,
                $enumType,
                $e,
            );
        }
    }
}