-
-
Notifications
You must be signed in to change notification settings - Fork 11
/
Uuid.php
185 lines (151 loc) · 5.73 KB
/
Uuid.php
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Uid;
/**
* @author Grégoire Pineau <[email protected]>
*
* @see https://datatracker.ietf.org/doc/html/rfc9562/#section-6.6 for details about namespaces
*/
class Uuid extends AbstractUid
{
public const NAMESPACE_DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
public const NAMESPACE_URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
public const NAMESPACE_OID = '6ba7b812-9dad-11d1-80b4-00c04fd430c8';
public const NAMESPACE_X500 = '6ba7b814-9dad-11d1-80b4-00c04fd430c8';
protected const TYPE = 0;
protected const NIL = '00000000-0000-0000-0000-000000000000';
protected const MAX = 'ffffffff-ffff-ffff-ffff-ffffffffffff';
public function __construct(string $uuid, bool $checkVariant = false)
{
$type = preg_match('{^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$}Di', $uuid) ? (int) $uuid[14] : false;
if (false === $type || (static::TYPE ?: $type) !== $type) {
throw new \InvalidArgumentException(sprintf('Invalid UUID%s: "%s".', static::TYPE ? 'v'.static::TYPE : '', $uuid));
}
$this->uid = strtolower($uuid);
if ($checkVariant && !\in_array($this->uid[19], ['8', '9', 'a', 'b'], true)) {
throw new \InvalidArgumentException(sprintf('Invalid UUID%s: "%s".', static::TYPE ? 'v'.static::TYPE : '', $uuid));
}
}
public static function fromString(string $uuid): static
{
if (22 === \strlen($uuid) && 22 === strspn($uuid, BinaryUtil::BASE58[''])) {
$uuid = str_pad(BinaryUtil::fromBase($uuid, BinaryUtil::BASE58), 16, "\0", \STR_PAD_LEFT);
}
if (16 === \strlen($uuid)) {
// don't use uuid_unparse(), it's slower
$uuid = bin2hex($uuid);
$uuid = substr_replace($uuid, '-', 8, 0);
$uuid = substr_replace($uuid, '-', 13, 0);
$uuid = substr_replace($uuid, '-', 18, 0);
$uuid = substr_replace($uuid, '-', 23, 0);
} elseif (26 === \strlen($uuid) && Ulid::isValid($uuid)) {
$ulid = new NilUlid();
$ulid->uid = strtoupper($uuid);
$uuid = $ulid->toRfc4122();
}
if (__CLASS__ !== static::class || 36 !== \strlen($uuid)) {
return new static($uuid);
}
if (self::NIL === $uuid) {
return new NilUuid();
}
if (self::MAX === $uuid = strtr($uuid, 'F', 'f')) {
return new MaxUuid();
}
if (!\in_array($uuid[19], ['8', '9', 'a', 'b', 'A', 'B'], true)) {
return new self($uuid);
}
return match ((int) $uuid[14]) {
UuidV1::TYPE => new UuidV1($uuid),
UuidV3::TYPE => new UuidV3($uuid),
UuidV4::TYPE => new UuidV4($uuid),
UuidV5::TYPE => new UuidV5($uuid),
UuidV6::TYPE => new UuidV6($uuid),
UuidV7::TYPE => new UuidV7($uuid),
UuidV8::TYPE => new UuidV8($uuid),
default => new self($uuid),
};
}
final public static function v1(): UuidV1
{
return new UuidV1();
}
final public static function v3(self $namespace, string $name): UuidV3
{
// don't use uuid_generate_md5(), some versions are buggy
$uuid = md5(hex2bin(str_replace('-', '', $namespace->uid)).$name, true);
return new UuidV3(self::format($uuid, '-3'));
}
final public static function v4(): UuidV4
{
return new UuidV4();
}
final public static function v5(self $namespace, string $name): UuidV5
{
// don't use uuid_generate_sha1(), some versions are buggy
$uuid = substr(sha1(hex2bin(str_replace('-', '', $namespace->uid)).$name, true), 0, 16);
return new UuidV5(self::format($uuid, '-5'));
}
final public static function v6(): UuidV6
{
return new UuidV6();
}
final public static function v7(): UuidV7
{
return new UuidV7();
}
final public static function v8(string $uuid): UuidV8
{
return new UuidV8($uuid);
}
public static function isValid(string $uuid): bool
{
if (self::NIL === $uuid && \in_array(static::class, [__CLASS__, NilUuid::class], true)) {
return true;
}
if (self::MAX === strtr($uuid, 'F', 'f') && \in_array(static::class, [__CLASS__, MaxUuid::class], true)) {
return true;
}
if (!preg_match('{^[0-9a-f]{8}(?:-[0-9a-f]{4}){2}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$}Di', $uuid)) {
return false;
}
return __CLASS__ === static::class || static::TYPE === (int) $uuid[14];
}
public function toBinary(): string
{
return hex2bin(str_replace('-', '', $this->uid));
}
/**
* Returns the identifier as a RFC 9562/4122 case insensitive string.
*
* @see https://datatracker.ietf.org/doc/html/rfc9562/#section-4
*
* @example 09748193-048a-4bfb-b825-8528cf74fdc1 (len=36)
*/
public function toRfc4122(): string
{
return $this->uid;
}
public function compare(AbstractUid $other): int
{
if (false !== $cmp = uuid_compare($this->uid, $other->uid)) {
return $cmp;
}
return parent::compare($other);
}
private static function format(string $uuid, string $version): string
{
$uuid[8] = $uuid[8] & "\x3F" | "\x80";
$uuid = substr_replace(bin2hex($uuid), '-', 8, 0);
$uuid = substr_replace($uuid, $version, 13, 1);
$uuid = substr_replace($uuid, '-', 18, 0);
return substr_replace($uuid, '-', 23, 0);
}
}