Debian Codegraph @

vendor/ramsey/uuid/src/FeatureSet.php

raw
1 <?php
2
3 /**
4 * This file is part of the ramsey/uuid library
5 *
6 * For the full copyright and license information, please view the LICENSE
7 * file that was distributed with this source code.
8 *
9 * @copyright Copyright (c) Ben Ramsey <[email protected]>
10 * @license http://opensource.org/licenses/MIT MIT
11 */
12
13 declare(strict_types=1);
14
15 namespace Ramsey\Uuid;
16
17 use Ramsey\Uuid\Builder\FallbackBuilder;
18 use Ramsey\Uuid\Builder\UuidBuilderInterface;
19 use Ramsey\Uuid\Codec\CodecInterface;
20 use Ramsey\Uuid\Codec\GuidStringCodec;
21 use Ramsey\Uuid\Codec\StringCodec;
22 use Ramsey\Uuid\Converter\Number\GenericNumberConverter;
23 use Ramsey\Uuid\Converter\NumberConverterInterface;
24 use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
25 use Ramsey\Uuid\Converter\Time\PhpTimeConverter;
26 use Ramsey\Uuid\Converter\TimeConverterInterface;
27 use Ramsey\Uuid\Generator\DceSecurityGenerator;
28 use Ramsey\Uuid\Generator\DceSecurityGeneratorInterface;
29 use Ramsey\Uuid\Generator\NameGeneratorFactory;
30 use Ramsey\Uuid\Generator\NameGeneratorInterface;
31 use Ramsey\Uuid\Generator\PeclUuidNameGenerator;
32 use Ramsey\Uuid\Generator\PeclUuidRandomGenerator;
33 use Ramsey\Uuid\Generator\PeclUuidTimeGenerator;
34 use Ramsey\Uuid\Generator\RandomGeneratorFactory;
35 use Ramsey\Uuid\Generator\RandomGeneratorInterface;
36 use Ramsey\Uuid\Generator\TimeGeneratorFactory;
37 use Ramsey\Uuid\Generator\TimeGeneratorInterface;
38 use Ramsey\Uuid\Generator\UnixTimeGenerator;
39 use Ramsey\Uuid\Guid\GuidBuilder;
40 use Ramsey\Uuid\Math\BrickMathCalculator;
41 use Ramsey\Uuid\Math\CalculatorInterface;
42 use Ramsey\Uuid\Nonstandard\UuidBuilder as NonstandardUuidBuilder;
43 use Ramsey\Uuid\Provider\Dce\SystemDceSecurityProvider;
44 use Ramsey\Uuid\Provider\DceSecurityProviderInterface;
45 use Ramsey\Uuid\Provider\Node\FallbackNodeProvider;
46 use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
47 use Ramsey\Uuid\Provider\Node\SystemNodeProvider;
48 use Ramsey\Uuid\Provider\NodeProviderInterface;
49 use Ramsey\Uuid\Provider\Time\SystemTimeProvider;
50 use Ramsey\Uuid\Provider\TimeProviderInterface;
51 use Ramsey\Uuid\Rfc4122\UuidBuilder as Rfc4122UuidBuilder;
52 use Ramsey\Uuid\Validator\GenericValidator;
53 use Ramsey\Uuid\Validator\ValidatorInterface;
54
55 use const PHP_INT_SIZE;
56
57 /**
58 * FeatureSet detects and exposes available features in the current environment
59 *
60 * A feature set is used by UuidFactory to determine the available features and capabilities of the environment.
61 */
62 class FeatureSet
63 {
64 private ?TimeProviderInterface $timeProvider = null;
65 private CalculatorInterface $calculator;
66 private CodecInterface $codec;
67 private DceSecurityGeneratorInterface $dceSecurityGenerator;
68 private NameGeneratorInterface $nameGenerator;
69 private NodeProviderInterface $nodeProvider;
70 private NumberConverterInterface $numberConverter;
71 private RandomGeneratorInterface $randomGenerator;
72 private TimeConverterInterface $timeConverter;
73 private TimeGeneratorInterface $timeGenerator;
74 private TimeGeneratorInterface $unixTimeGenerator;
75 private UuidBuilderInterface $builder;
76 private ValidatorInterface $validator;
77
78 /**
79 * @param bool $useGuids True build UUIDs using the GuidStringCodec
80 * @param bool $force32Bit True to force the use of 32-bit functionality (primarily for testing purposes)
81 * @param bool $forceNoBigNumber (obsolete)
82 * @param bool $ignoreSystemNode True to disable attempts to check for the system node ID (primarily for testing purposes)
83 * @param bool $enablePecl True to enable the use of the PeclUuidTimeGenerator to generate version 1 UUIDs
84 *
85 * @phpstan-ignore constructor.unusedParameter ($forceNoBigNumber is deprecated)
86 */
87 public function __construct(
88 bool $useGuids = false,
89 private bool $force32Bit = false,
90 bool $forceNoBigNumber = false,
91 private bool $ignoreSystemNode = false,
92 private bool $enablePecl = false,
93 ) {
94 $this->randomGenerator = $this->buildRandomGenerator();
95 $this->setCalculator(new BrickMathCalculator());
96 $this->builder = $this->buildUuidBuilder($useGuids);
97 $this->codec = $this->buildCodec($useGuids);
98 $this->nodeProvider = $this->buildNodeProvider();
99 $this->nameGenerator = $this->buildNameGenerator();
100 $this->setTimeProvider(new SystemTimeProvider());
101 $this->setDceSecurityProvider(new SystemDceSecurityProvider());
102 $this->validator = new GenericValidator();
103
104 assert($this->timeProvider !== null);
105 $this->unixTimeGenerator = $this->buildUnixTimeGenerator();
106 }
107
108 /**
109 * Returns the builder configured for this environment
110 */
111 public function getBuilder(): UuidBuilderInterface
112 {
113 return $this->builder;
114 }
115
116 /**
117 * Returns the calculator configured for this environment
118 */
119 public function getCalculator(): CalculatorInterface
120 {
121 return $this->calculator;
122 }
123
124 /**
125 * Returns the codec configured for this environment
126 */
127 public function getCodec(): CodecInterface
128 {
129 return $this->codec;
130 }
131
132 /**
133 * Returns the DCE Security generator configured for this environment
134 */
135 public function getDceSecurityGenerator(): DceSecurityGeneratorInterface
136 {
137 return $this->dceSecurityGenerator;
138 }
139
140 /**
141 * Returns the name generator configured for this environment
142 */
143 public function getNameGenerator(): NameGeneratorInterface
144 {
145 return $this->nameGenerator;
146 }
147
148 /**
149 * Returns the node provider configured for this environment
150 */
151 public function getNodeProvider(): NodeProviderInterface
152 {
153 return $this->nodeProvider;
154 }
155
156 /**
157 * Returns the number converter configured for this environment
158 */
159 public function getNumberConverter(): NumberConverterInterface
160 {
161 return $this->numberConverter;
162 }
163
164 /**
165 * Returns the random generator configured for this environment
166 */
167 public function getRandomGenerator(): RandomGeneratorInterface
168 {
169 return $this->randomGenerator;
170 }
171
172 /**
173 * Returns the time converter configured for this environment
174 */
175 public function getTimeConverter(): TimeConverterInterface
176 {
177 return $this->timeConverter;
178 }
179
180 /**
181 * Returns the time generator configured for this environment
182 */
183 public function getTimeGenerator(): TimeGeneratorInterface
184 {
185 return $this->timeGenerator;
186 }
187
188 /**
189 * Returns the Unix Epoch time generator configured for this environment
190 */
191 public function getUnixTimeGenerator(): TimeGeneratorInterface
192 {
193 return $this->unixTimeGenerator;
194 }
195
196 /**
197 * Returns the validator configured for this environment
198 */
199 public function getValidator(): ValidatorInterface
200 {
201 return $this->validator;
202 }
203
204 /**
205 * Sets the calculator to use in this environment
206 */
207 public function setCalculator(CalculatorInterface $calculator): void
208 {
209 $this->calculator = $calculator;
210 $this->numberConverter = $this->buildNumberConverter($calculator);
211 $this->timeConverter = $this->buildTimeConverter($calculator);
212
213 if (isset($this->timeProvider)) {
214 $this->timeGenerator = $this->buildTimeGenerator($this->timeProvider);
215 }
216 }
217
218 /**
219 * Sets the DCE Security provider to use in this environment
220 */
221 public function setDceSecurityProvider(DceSecurityProviderInterface $dceSecurityProvider): void
222 {
223 $this->dceSecurityGenerator = $this->buildDceSecurityGenerator($dceSecurityProvider);
224 }
225
226 /**
227 * Sets the node provider to use in this environment
228 */
229 public function setNodeProvider(NodeProviderInterface $nodeProvider): void
230 {
231 $this->nodeProvider = $nodeProvider;
232
233 if (isset($this->timeProvider)) {
234 $this->timeGenerator = $this->buildTimeGenerator($this->timeProvider);
235 }
236 }
237
238 /**
239 * Sets the time provider to use in this environment
240 */
241 public function setTimeProvider(TimeProviderInterface $timeProvider): void
242 {
243 $this->timeProvider = $timeProvider;
244 $this->timeGenerator = $this->buildTimeGenerator($timeProvider);
245 }
246
247 /**
248 * Set the validator to use in this environment
249 */
250 public function setValidator(ValidatorInterface $validator): void
251 {
252 $this->validator = $validator;
253 }
254
255 /**
256 * Returns a codec configured for this environment
257 *
258 * @param bool $useGuids Whether to build UUIDs using the GuidStringCodec
259 */
260 private function buildCodec(bool $useGuids = false): CodecInterface
261 {
262 if ($useGuids) {
263 return new GuidStringCodec($this->builder);
264 }
265
266 return new StringCodec($this->builder);
267 }
268
269 /**
270 * Returns a DCE Security generator configured for this environment
271 */
272 private function buildDceSecurityGenerator(
273 DceSecurityProviderInterface $dceSecurityProvider,
274 ): DceSecurityGeneratorInterface {
275 return new DceSecurityGenerator($this->numberConverter, $this->timeGenerator, $dceSecurityProvider);
276 }
277
278 /**
279 * Returns a node provider configured for this environment
280 */
281 private function buildNodeProvider(): NodeProviderInterface
282 {
283 if ($this->ignoreSystemNode) {
284 return new RandomNodeProvider();
285 }
286
287 return new FallbackNodeProvider([new SystemNodeProvider(), new RandomNodeProvider()]);
288 }
289
290 /**
291 * Returns a number converter configured for this environment
292 */
293 private function buildNumberConverter(CalculatorInterface $calculator): NumberConverterInterface
294 {
295 return new GenericNumberConverter($calculator);
296 }
297
298 /**
299 * Returns a random generator configured for this environment
300 */
301 private function buildRandomGenerator(): RandomGeneratorInterface
302 {
303 if ($this->enablePecl) {
304 return new PeclUuidRandomGenerator();
305 }
306
307 return (new RandomGeneratorFactory())->getGenerator();
308 }
309
310 /**
311 * Returns a time generator configured for this environment
312 *
313 * @param TimeProviderInterface $timeProvider The time provider to use with
314 * the time generator
315 */
316 private function buildTimeGenerator(TimeProviderInterface $timeProvider): TimeGeneratorInterface
317 {
318 if ($this->enablePecl) {
319 return new PeclUuidTimeGenerator();
320 }
321
322 return (new TimeGeneratorFactory($this->nodeProvider, $this->timeConverter, $timeProvider))->getGenerator();
323 }
324
325 /**
326 * Returns a Unix Epoch time generator configured for this environment
327 */
328 private function buildUnixTimeGenerator(): TimeGeneratorInterface
329 {
330 return new UnixTimeGenerator($this->randomGenerator);
331 }
332
333 /**
334 * Returns a name generator configured for this environment
335 */
336 private function buildNameGenerator(): NameGeneratorInterface
337 {
338 if ($this->enablePecl) {
339 return new PeclUuidNameGenerator();
340 }
341
342 return (new NameGeneratorFactory())->getGenerator();
343 }
344
345 /**
346 * Returns a time converter configured for this environment
347 */
348 private function buildTimeConverter(CalculatorInterface $calculator): TimeConverterInterface
349 {
350 $genericConverter = new GenericTimeConverter($calculator);
351
352 if ($this->is64BitSystem()) {
353 return new PhpTimeConverter($calculator, $genericConverter);
354 }
355
356 return $genericConverter;
357 }
358
359 /**
360 * Returns a UUID builder configured for this environment
361 *
362 * @param bool $useGuids Whether to build UUIDs using the GuidStringCodec
363 */
364 private function buildUuidBuilder(bool $useGuids = false): UuidBuilderInterface
365 {
366 if ($useGuids) {
367 return new GuidBuilder($this->numberConverter, $this->timeConverter);
368 }
369
370 return new FallbackBuilder([
371 new Rfc4122UuidBuilder($this->numberConverter, $this->timeConverter),
372 new NonstandardUuidBuilder($this->numberConverter, $this->timeConverter),
373 ]);
374 }
375
376 /**
377 * Returns true if the PHP build is 64-bit
378 */
379 private function is64BitSystem(): bool
380 {
381 return PHP_INT_SIZE === 8 && !$this->force32Bit;
382 }
383 }