vendor/shopware/core/Framework/Uuid/Uuid.php line 84

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Uuid;
  5. use Shopware\Core\Framework\Uuid\Exception\InvalidUuidException;
  6. use Shopware\Core\Framework\Uuid\Exception\InvalidUuidLengthException;
  8. class Uuid
  9. {
  10.     /**
  11.      * Regular expression pattern for matching a valid UUID of any variant.
  12.      */
  13.     public const VALID_PATTERN = '^[0-9a-f]{32}$';
  15.     public static function randomHex(): string
  16.     {
  17.         $hex = bin2hex(random_bytes(16));
  18.         $timeHi = self::applyVersion(mb_substr($hex, 12, 4), 4);
  19.         $clockSeqHi = self::applyVariant(hexdec(mb_substr($hex, 16, 2)));
  21.         return sprintf(
  22.             '%08s%04s%04s%02s%02s%012s',
  23.             // time low
  24.             mb_substr($hex, 0, 8),
  25.             // time mid
  26.             mb_substr($hex, 8, 4),
  27.             // time high and version
  28.             str_pad(dechex($timeHi), 4, '0', \STR_PAD_LEFT),
  29.             // clk_seq_hi_res
  30.             str_pad(dechex($clockSeqHi), 2, '0', \STR_PAD_LEFT),
  31.             // clock_seq_low
  32.             mb_substr($hex, 18, 2),
  33.             // node
  34.             mb_substr($hex, 20, 12)
  35.         );
  36.     }
  38.     public static function randomBytes(): string
  39.     {
  40.         return hex2bin(self::randomHex());
  41.     }
  43.     /**
  44.      * @throws InvalidUuidException
  45.      * @throws InvalidUuidLengthException
  46.      */
  47.     public static function fromBytesToHex(string $bytes): string
  48.     {
  49.         if (mb_strlen($bytes, '8bit') !== 16) {
  50.             throw new InvalidUuidLengthException(mb_strlen($bytes, '8bit'), bin2hex($bytes));
  51.         }
  52.         $uuid = bin2hex($bytes);
  54.         if (!self::isValid($uuid)) {
  55.             throw new InvalidUuidException($uuid);
  56.         }
  58.         return $uuid;
  59.     }
  61.     public static function fromBytesToHexList(array $bytesList): array
  62.     {
  63.         $converted = [];
  64.         foreach ($bytesList as $key => $bytes) {
  65.             $converted[$key] = self::fromBytesToHex($bytes);
  66.         }
  68.         return $converted;
  69.     }
  71.     public static function fromHexToBytesList(array $uuids): array
  72.     {
  73.         $converted = [];
  74.         foreach ($uuids as $key => $uuid) {
  75.             $converted[$key] = self::fromHexToBytes($uuid);
  76.         }
  78.         return $converted;
  79.     }
  81.     /**
  82.      * @throws InvalidUuidException
  83.      */
  84.     public static function fromHexToBytes(string $uuid): string
  85.     {
  86.         if ($bin = @hex2bin($uuid)) {
  87.             return $bin;
  88.         }
  90.         throw new InvalidUuidException($uuid);
  91.     }
  93.     /**
  94.      * Generates a md5 binary, to hash the string and returns a UUID in hex
  95.      */
  96.     public static function fromStringToHex(string $string): string
  97.     {
  98.         return self::fromBytesToHex(md5($string, true));
  99.     }
  101.     public static function isValid(string $id): bool
  102.     {
  103.         if (!preg_match('/' . self::VALID_PATTERN . '/', $id)) {
  104.             return false;
  105.         }
  107.         return true;
  108.     }
  110.     private static function applyVersion(string $timeHi, int $version): int
  111.     {
  112.         $timeHi = hexdec($timeHi) & 0x0fff;
  113.         $timeHi &= ~0xf000;
  114.         $timeHi |= $version << 12;
  116.         return $timeHi;
  117.     }
  119.     private static function applyVariant(int $clockSeqHi): int
  120.     {
  121.         // Set the variant to RFC 4122
  122.         $clockSeqHi &= 0x3f;
  123.         $clockSeqHi &= ~0xc0;
  124.         $clockSeqHi |= 0x80;
  126.         return $clockSeqHi;
  127.     }
  128. }