Debian Codegraph @

vendor/ramsey/uuid/src/FeatureSet.php

raw
1 <?php
2 /**
3 * This file is part of the ramsey/uuid library
4 *
5 * For the full copyright and license information, please view the LICENSE
6 * file that was distributed with this source code.
7 *
8 * @copyright Copyright (c) Ben Ramsey <[email protected]>
9 * @license http://opensource.org/licenses/MIT MIT
10 * @link https://benramsey.com/projects/ramsey-uuid/ Documentation
11 * @link https://packagist.org/packages/ramsey/uuid Packagist
12 * @link https://github.com/ramsey/uuid GitHub
13 */
14
15 namespace Ramsey\Uuid;
16
17 use Ramsey\Uuid\Converter\TimeConverterInterface;
18 use Ramsey\Uuid\Generator\PeclUuidTimeGenerator;
19 use Ramsey\Uuid\Provider\Node\FallbackNodeProvider;
20 use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
21 use Ramsey\Uuid\Provider\Node\SystemNodeProvider;
22 use Ramsey\Uuid\Converter\NumberConverterInterface;
23 use Ramsey\Uuid\Converter\Number\BigNumberConverter;
24 use Ramsey\Uuid\Converter\Number\DegradedNumberConverter;
25 use Ramsey\Uuid\Converter\Time\BigNumberTimeConverter;
26 use Ramsey\Uuid\Converter\Time\DegradedTimeConverter;
27 use Ramsey\Uuid\Converter\Time\PhpTimeConverter;
28 use Ramsey\Uuid\Provider\Time\SystemTimeProvider;
29 use Ramsey\Uuid\Builder\UuidBuilderInterface;
30 use Ramsey\Uuid\Builder\DefaultUuidBuilder;
31 use Ramsey\Uuid\Codec\CodecInterface;
32 use Ramsey\Uuid\Codec\StringCodec;
33 use Ramsey\Uuid\Codec\GuidStringCodec;
34 use Ramsey\Uuid\Builder\DegradedUuidBuilder;
35 use Ramsey\Uuid\Generator\RandomGeneratorFactory;
36 use Ramsey\Uuid\Generator\RandomGeneratorInterface;
37 use Ramsey\Uuid\Generator\TimeGeneratorFactory;
38 use Ramsey\Uuid\Generator\TimeGeneratorInterface;
39 use Ramsey\Uuid\Provider\TimeProviderInterface;
40 use Ramsey\Uuid\Provider\NodeProviderInterface;
41
42 /**
43 * FeatureSet detects and exposes available features in the current environment
44 * (32- or 64-bit, available dependencies, etc.)
45 */
46 class FeatureSet
47 {
48 /**
49 * @var bool
50 */
51 private $disableBigNumber = false;
52
53 /**
54 * @var bool
55 */
56 private $disable64Bit = false;
57
58 /**
59 * @var bool
60 */
61 private $ignoreSystemNode = false;
62
63 /**
64 * @var bool
65 */
66 private $enablePecl = false;
67
68 /**
69 * @var UuidBuilderInterface
70 */
71 private $builder;
72
73 /**
74 * @var CodecInterface
75 */
76 private $codec;
77
78 /**
79 * @var NodeProviderInterface
80 */
81 private $nodeProvider;
82
83 /**
84 * @var NumberConverterInterface
85 */
86 private $numberConverter;
87
88 /**
89 * @var RandomGeneratorInterface
90 */
91 private $randomGenerator;
92
93 /**
94 * @var TimeGeneratorInterface
95 */
96 private $timeGenerator;
97
98 /**
99 * Constructs a `FeatureSet` for use by a `UuidFactory` to determine or set
100 * features available to the environment
101 *
102 * @param bool $useGuids Whether to build UUIDs using the `GuidStringCodec`
103 * @param bool $force32Bit Whether to force the use of 32-bit functionality
104 * (primarily for testing purposes)
105 * @param bool $forceNoBigNumber Whether to disable the use of moontoast/math
106 * `BigNumber` (primarily for testing purposes)
107 * @param bool $ignoreSystemNode Whether to disable attempts to check for
108 * the system host ID (primarily for testing purposes)
109 * @param bool $enablePecl Whether to enable the use of the `PeclUuidTimeGenerator`
110 * to generate version 1 UUIDs
111 */
112 public function __construct(
113 $useGuids = false,
114 $force32Bit = false,
115 $forceNoBigNumber = false,
116 $ignoreSystemNode = false,
117 $enablePecl = false
118 ) {
119 $this->disableBigNumber = $forceNoBigNumber;
120 $this->disable64Bit = $force32Bit;
121 $this->ignoreSystemNode = $ignoreSystemNode;
122 $this->enablePecl = $enablePecl;
123
124 $this->numberConverter = $this->buildNumberConverter();
125 $this->builder = $this->buildUuidBuilder();
126 $this->codec = $this->buildCodec($useGuids);
127 $this->nodeProvider = $this->buildNodeProvider();
128 $this->randomGenerator = $this->buildRandomGenerator();
129 $this->setTimeProvider(new SystemTimeProvider());
130 }
131
132 /**
133 * Returns the builder configured for this environment
134 *
135 * @return UuidBuilderInterface
136 */
137 public function getBuilder()
138 {
139 return $this->builder;
140 }
141
142 /**
143 * Returns the UUID UUID coder-decoder configured for this environment
144 *
145 * @return CodecInterface
146 */
147 public function getCodec()
148 {
149 return $this->codec;
150 }
151
152 /**
153 * Returns the system node ID provider configured for this environment
154 *
155 * @return NodeProviderInterface
156 */
157 public function getNodeProvider()
158 {
159 return $this->nodeProvider;
160 }
161
162 /**
163 * Returns the number converter configured for this environment
164 *
165 * @return NumberConverterInterface
166 */
167 public function getNumberConverter()
168 {
169 return $this->numberConverter;
170 }
171
172 /**
173 * Returns the random UUID generator configured for this environment
174 *
175 * @return RandomGeneratorInterface
176 */
177 public function getRandomGenerator()
178 {
179 return $this->randomGenerator;
180 }
181
182 /**
183 * Returns the time-based UUID generator configured for this environment
184 *
185 * @return TimeGeneratorInterface
186 */
187 public function getTimeGenerator()
188 {
189 return $this->timeGenerator;
190 }
191
192 /**
193 * Sets the time provider for use in this environment
194 *
195 * @param TimeProviderInterface $timeProvider
196 */
197 public function setTimeProvider(TimeProviderInterface $timeProvider)
198 {
199 $this->timeGenerator = $this->buildTimeGenerator($timeProvider);
200 }
201
202 /**
203 * Determines which UUID coder-decoder to use and returns the configured
204 * codec for this environment
205 *
206 * @param bool $useGuids Whether to build UUIDs using the `GuidStringCodec`
207 * @return CodecInterface
208 */
209 protected function buildCodec($useGuids = false)
210 {
211 if ($useGuids) {
212 return new GuidStringCodec($this->builder);
213 }
214
215 return new StringCodec($this->builder);
216 }
217
218 /**
219 * Determines which system node ID provider to use and returns the configured
220 * system node ID provider for this environment
221 *
222 * @return NodeProviderInterface
223 */
224 protected function buildNodeProvider()
225 {
226 if ($this->ignoreSystemNode) {
227 return new RandomNodeProvider();
228 }
229
230 return new FallbackNodeProvider([
231 new SystemNodeProvider(),
232 new RandomNodeProvider()
233 ]);
234 }
235
236 /**
237 * Determines which number converter to use and returns the configured
238 * number converter for this environment
239 *
240 * @return NumberConverterInterface
241 */
242 protected function buildNumberConverter()
243 {
244 if ($this->hasBigNumber()) {
245 return new BigNumberConverter();
246 }
247
248 return new DegradedNumberConverter();
249 }
250
251 /**
252 * Determines which random UUID generator to use and returns the configured
253 * random UUID generator for this environment
254 *
255 * @return RandomGeneratorInterface
256 */
257 protected function buildRandomGenerator()
258 {
259 return (new RandomGeneratorFactory())->getGenerator();
260 }
261
262 /**
263 * Determines which time-based UUID generator to use and returns the configured
264 * time-based UUID generator for this environment
265 *
266 * @param TimeProviderInterface $timeProvider
267 * @return TimeGeneratorInterface
268 */
269 protected function buildTimeGenerator(TimeProviderInterface $timeProvider)
270 {
271 if ($this->enablePecl) {
272 return new PeclUuidTimeGenerator();
273 }
274
275 return (new TimeGeneratorFactory(
276 $this->nodeProvider,
277 $this->buildTimeConverter(),
278 $timeProvider
279 ))->getGenerator();
280 }
281
282 /**
283 * Determines which time converter to use and returns the configured
284 * time converter for this environment
285 *
286 * @return TimeConverterInterface
287 */
288 protected function buildTimeConverter()
289 {
290 if ($this->is64BitSystem()) {
291 return new PhpTimeConverter();
292 }
293
294 if ($this->hasBigNumber()) {
295 return new BigNumberTimeConverter();
296 }
297
298 return new DegradedTimeConverter();
299 }
300
301 /**
302 * Determines which UUID builder to use and returns the configured UUID
303 * builder for this environment
304 *
305 * @return UuidBuilderInterface
306 */
307 protected function buildUuidBuilder()
308 {
309 if ($this->is64BitSystem()) {
310 return new DefaultUuidBuilder($this->numberConverter);
311 }
312
313 return new DegradedUuidBuilder($this->numberConverter);
314 }
315
316 /**
317 * Returns true if the system has `Moontoast\Math\BigNumber`
318 *
319 * @return bool
320 */
321 protected function hasBigNumber()
322 {
323 return class_exists('Moontoast\Math\BigNumber') && !$this->disableBigNumber;
324 }
325
326 /**
327 * Returns true if the system is 64-bit, false otherwise
328 *
329 * @return bool
330 */
331 protected function is64BitSystem()
332 {
333 return PHP_INT_SIZE == 8 && !$this->disable64Bit;
334 }
335 }