{

protected const TYPE = 7;

private static string $time = '';

private static int $subMs = 0;

private static array $rand = [];

private static string $seed;

private static array $seedParts;

private static int $seedIndex = 0;

public function __construct(?string $uuid = null)

{

if (null === $uuid) {

$this->uid = static::generate();

} else {

parent::__construct($uuid, true);

}

}

public function getDateTime(): \DateTimeImmutable

{

$time = substr($this->uid, 0, 8).substr($this->uid, 9, 4);

if (\PHP_INT_SIZE >= 8) {

$time = hexdec($time);

return \DateTimeImmutable::createFromTimestamp(intdiv($time, 1000))->setMicrosecond($time % 1000 * 1000 + (hexdec(substr($this->uid, 14, 4)) >> 2 & 0x3FF) % 1000);

}

$time = BinaryUtil::toBase(hex2bin($time), BinaryUtil::BASE10);

if (4 > \strlen($time)) {

$time = '000'.$time;

}

$time .= substr(1000 + (hexdec(substr($this->uid, 14, 4)) >> 2 & 0x3FF), -3);

return \DateTimeImmutable::createFromFormat('U.u', substr_replace($time, '.', -6, 0));

}

/**

public static function createBoundaries(?\DateTimeInterface $time = null): array

{

if (null === $time) {

$time = microtime(false);

$time = substr($time, 11).substr($time, 2, 3);

} elseif (0 > $time = $time->format('Uv')) {

throw new InvalidArgumentException('The timestamp must be positive.');

}

$time = \PHP_INT_SIZE >= 8 ? \sprintf('%012x', $time) : str_pad(bin2hex(BinaryUtil::fromBase($time, BinaryUtil::BASE10)), 12, '0', \STR_PAD_LEFT);

$time = substr_replace($time, '-', 8, 0);

return [static::fromString($time.'-7000-8000-000000000000'), static::fromString($time.'-7fff-bfff-ffffffffffff')];

}

public static function generate(?\DateTimeInterface $time = null): string

{

if (null === $mtime = $time) {

if (\PHP_INT_SIZE >= 8) {

// microtime(true) is faster than microtime(false), and precise enough to give the exact microsecond

$time = (int) (microtime(true) * 1000000 + .5);

$subMs = $time % 1000;

$time = (string) intdiv($time, 1000);

} else {

$time = microtime(false);

$subMs = (int) substr($time, 5, 3);

$time = substr($time, 11).substr($time, 2, 3);

}

} elseif (0 > $time = $time->format('Uu')) {

throw new InvalidArgumentException('The timestamp must be positive.');

} else {

$subMs = (int) substr($time, -3);

$time = substr($time, 0, -3);

}

if ($time > self::$time || (null !== $mtime && $time !== self::$time)) {

randomize:

self::$rand = unpack(\PHP_INT_SIZE >= 8 ? 'L*' : 'S*', isset(self::$seed) ? random_bytes(8) : self::$seed = random_bytes(16));

self::$time = $time;

} else {

// When the clock goes backwards, keep the sub-millisecond part from going backwards too

if (null === $mtime && $subMs < self::$subMs) {

$subMs = self::$subMs;

}

// Within the same ms, we increment the rand part by a random 24-bit number.

// Instead of getting this number from random_bytes(), which is slow, we get

// it by sha512-hashing self::$seed. This produces 64 bytes of entropy,

// which we need to split in a list of 24-bit numbers. unpack() first splits

// them into 16 x 32-bit numbers; we take the first byte of each of these

// numbers to get 5 extra 24-bit numbers. Then, we consume those numbers

// one-by-one and run this logic every 21 iterations.

// self::$rand holds the random part of the UUID, split into 2 x 32-bit numbers

// or 4 x 16-bit for x86 portability. We increment this random part by the next

// 24-bit number in the self::$seedParts list and decrement self::$seedIndex.

if (!self::$seedIndex) {

$s = unpack(\PHP_INT_SIZE >= 8 ? 'L*' : 'l*', self::$seed = hash('sha512', self::$seed, true));

$s[] = ($s[1] >> 8 & 0xFF0000) | ($s[2] >> 16 & 0xFF00) | ($s[3] >> 24 & 0xFF);

$s[] = ($s[4] >> 8 & 0xFF0000) | ($s[5] >> 16 & 0xFF00) | ($s[6] >> 24 & 0xFF);

$s[] = ($s[7] >> 8 & 0xFF0000) | ($s[8] >> 16 & 0xFF00) | ($s[9] >> 24 & 0xFF);

$s[] = ($s[10] >> 8 & 0xFF0000) | ($s[11] >> 16 & 0xFF00) | ($s[12] >> 24 & 0xFF);

$s[] = ($s[13] >> 8 & 0xFF0000) | ($s[14] >> 16 & 0xFF00) | ($s[15] >> 24 & 0xFF);

self::$seedParts = $s;

self::$seedIndex = 21;

}

if (\PHP_INT_SIZE >= 8) {

self::$rand[2] = 0xFFFFFFFF & $carry = self::$rand[2] + 1 + (self::$seedParts[self::$seedIndex--] & 0xFFFFFF);

self::$rand[1] = 0xFFFFFFFF & $carry = self::$rand[1] + ($carry >> 32);

$carry >>= 32;

} else {

self::$rand[4] = 0xFFFF & $carry = self::$rand[4] + 1 + (self::$seedParts[self::$seedIndex--] & 0xFFFFFF);

self::$rand[3] = 0xFFFF & $carry = self::$rand[3] + ($carry >> 16);

self::$rand[2] = 0xFFFF & $carry = self::$rand[2] + ($carry >> 16);

self::$rand[1] = 0xFFFF & $carry = self::$rand[1] + ($carry >> 16);

$carry >>= 16;

}

if ($carry && $subMs <= self::$subMs) {

usleep(1);

if (1024 <= ++$subMs) {

if (\PHP_INT_SIZE >= 8 || 10 > \strlen($time = self::$time)) {

$time = (string) (1 + $time);

} elseif ('999999999' === $mtime = substr($time, -9)) {

$time = (1 + substr($time, 0, -9)).'000000000';

} else {

$time = substr_replace($time, str_pad(++$mtime, 9, '0', \STR_PAD_LEFT), -9);

}

goto randomize;

}

}

$time = self::$time;

}

self::$subMs = $subMs;

if (\PHP_INT_SIZE >= 8) {

return substr_replace(\sprintf('%012x-%04x-%04x-%04x%08x',

$time,

0x7000 | ($subMs << 2) | (self::$rand[1] >> 30),

0x8000 | (self::$rand[1] >> 16 & 0x3FFF),

self::$rand[1] & 0xFFFF,

self::$rand[2],

), '-', 8, 0);

}

return substr_replace(\sprintf('%012s-%04x-%04x-%04x%04x%04x',

bin2hex(BinaryUtil::fromBase($time, BinaryUtil::BASE10)),

0x7000 | ($subMs << 2) | (self::$rand[1] >> 14),

0x8000 | (self::$rand[1] & 0x3FFF),

self::$rand[2],

self::$rand[3],

self::$rand[4],

), '-', 8, 0);

}