enum/BaseEnum.php at master · vayes/enum · GitHub

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
<?php

namespace Vayes\Enum;

use ReflectionException;

/**
 * BasicEnum
 *
 * @author Brian Gebel <brian@pixeloven.com>
 * @link https://github.com/pixeloven/BasicEnum-PHP
 * @copyright 2015 PixelOven (Under MIT License)
 *
 * Allows for basic enumeration in PHP
 *
 */

abstract class BaseEnum {

    // Static Variables
    private static $constCacheArray = NULL;

    /**
     * Returns a value array
     *
     * @return array
     */
    public static function getOptions(): array
    {
        return array_values(self::getConstants());
    }

    /**
     * Checks if name exists in enum
     *
     * @param      $name
     * @param bool $strict
     * @return bool
     */
    public static function isValidName($name, $strict = false)
    {
        $constants = self::getConstants();

        if ($strict) {
            return array_key_exists($name, $constants);
        }

        $keys = array_map('strtolower', array_keys($constants));

        return in_array(strtolower($name), $keys);
    }

    /**
     * Checks if value exists in enum
     *
     * @param $value
     * @return bool
     */
    public static function isValidValue($value)
    {
        $values = array_values(self::getConstants());

        return in_array($value, $values, $strict = true);
    }

    /**
     * Returns value with a given name
     *
     * @param $name
     * @return bool|mixed
     */
    public static function getValueByName($name)
    {
        $constants = self::getConstants();

        $name = strtoupper($name);

        if (array_key_exists($name, $constants)) {
            return $constants[$name];
        }

        return false;
    }

    /**
     * Returns the name of the constant with a given value
     * If Enum has non-unqiue values then the first instance is returned
     * Should have it return array of constants with given value
     *
     * @param string $value
     * @return mixed
     */
    public static function getNameByValue($value)
    {
        $constants = self::getConstants();

        $flip = array_flip($constants);

        if (array_key_exists($value, $flip)) {
            return $flip[$value];
        }

        return false;
    }

    /**
     * Gets constant from defined enum
     *
     * @return mixed
     */
    private static function getConstants()
    {
        if (self::$constCacheArray == NULL) {
            self::$constCacheArray = [];
        }

        $calledClass = get_called_class();

        if (!array_key_exists($calledClass, self::$constCacheArray)) {
            try {
                $reflect = new \ReflectionClass($calledClass);
            } catch (ReflectionException $e) {
                throw new $e;
            }
            self::$constCacheArray[$calledClass] = $reflect->getConstants();
        }

        return self::$constCacheArray[$calledClass];
    }
}