Ramsey UUID

https://github.com/ramsey/uuid
Admin
A PHP library for generating and working with universally unique identifiers (UUIDs) according to...
Tokens:117,349
Snippets:910
Trust Score:10
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start Vagrant VM and SSH

Source: https://github.com/ramsey/uuid/blob/4.x/resources/vagrant/windows/README.md

Navigate to the Vagrant directory and start the VM, then SSH into it.

```bash
cd /path/to/uuid/resources/vagrant/windows
vagrant up
vagrant ssh
```

--------------------------------

### Start Vagrant VM

Source: https://github.com/ramsey/uuid/blob/4.x/resources/vagrant/linux/README.md

Navigate to the Vagrant directory and start the VM with 'vagrant up', then SSH into it with 'vagrant ssh'.

```bash
cd /path/to/uuid/resources/vagrant/linux
vagrant up
vagrant ssh
```

--------------------------------

### Set up virtualenv and install dependencies

Source: https://github.com/ramsey/uuid/blob/4.x/docs/README.md

Creates a virtualenv named 'ramsey-uuid-docs', activates it, and installs the documentation requirements. Run these commands from the docs/ directory.

```bash
pip install virtualenvwrapper
mkvirtualenv ramsey-uuid-docs
cd docs/
workon ramsey-uuid-docs
pip install -r requirements.txt
```

--------------------------------

### Start FreeBSD Vagrant VM

Source: https://github.com/ramsey/uuid/blob/4.x/resources/vagrant/freebsd/README.md

Navigate to the FreeBSD Vagrant directory, start the VM, and SSH into it.

```bash
cd /path/to/uuid/resources/vagrant/freebsd
vagrant up
vagrant ssh
```

--------------------------------

### Clone and install dependencies

Source: https://github.com/ramsey/uuid/blob/4.x/CONTRIBUTING.md

Run these commands after cloning the repository to install project dependencies with Composer.

```bash
cd /path/to/repository
composer install
```

--------------------------------

### Output of decoding GUID bytes

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Example output from the previous PHP snippet, showing the resulting Guid class, GUID string, version, and bytes.

```text
Class: Ramsey\Uuid\Guid\Guid
GUID: fc93ab0e-c99e-4b58-975e-9c5e68c53624
Version: 4
Bytes: 0eab93fc9ec9584b975e9c5e68c53624
```

--------------------------------

### GUID byte arrangement

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Shows the byte arrangement of the GUID from the example, highlighting the little-endian order for the first 64 bits.

```text
0e ab 93 fc 9e c9 58 4b 97 5e 9c 5e 68 c5 36 24
```

--------------------------------

### Install ramsey/uuid with Composer

Source: https://github.com/ramsey/uuid/blob/4.x/README.md

Run this command to install the package and add it as a requirement to your project's composer.json.

```bash
composer require ramsey/uuid
```

--------------------------------

### Output of converting GUID to UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Example output from the previous PHP snippet, showing the resulting UuidV4 class, UUID string, version, and bytes.

```text
Class: Ramsey\Uuid\Rfc4122\UuidV4
UUID: fc93ab0e-c99e-4b58-975e-9c5e68c53624
Version: 4
Bytes: fc93ab0ec99e4b58975e9c5e68c53624
```

--------------------------------

### Example output of version 1 UUID generation

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version1.rst

Shows the expected output format from the previous example. The output includes the UUID string, version number, creation date in RFC 2822 format, and the node (MAC address).

```text
UUID: e22e1622-5c14-11ea-b2f3-0242ac130003
Version: 1
Date: Sun, 01 Mar 2020 23:32:15 +0000
Node: 0242ac130003
```

--------------------------------

### Decode GUID bytes with FeatureSet and UuidFactory

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Creates a UuidFactory with GUID support enabled and decodes a 16-byte GUID string into a Ramsey\Uuid\Guid\Guid instance. The example prints the class, GUID string, version, and bytes. Note that the byte order differs from the string representation.

```php
use Ramsey\Uuid\FeatureSet;
use Ramsey\Uuid\UuidFactory;

// The bytes of a GUID previously stored in some datastore.
$guidBytes = hex2bin('0eab93fc9ec9584b975e9c5e68c53624');

$useGuids = true;
$featureSet = new FeatureSet($useGuids);
$factory = new UuidFactory($featureSet);

$guid = $factory->fromBytes($guidBytes);

printf(
    "Class: %s\nGUID: %s\nVersion: %d\nBytes: %s\n",
    get_class($guid),
    $guid->toString(),
    $guid->getFields()->getVersion(),
    bin2hex($guid->getBytes())
);
```

--------------------------------

### Run tests inside FreeBSD VM

Source: https://github.com/ramsey/uuid/blob/4.x/resources/vagrant/freebsd/README.md

Once inside the VM, install dependencies and run the test suite with a timeout of zero.

```bash
cd uuid/
composer install
composer run-script --timeout=0 test
```

--------------------------------

### Build HTML documentation with make html

Source: https://github.com/ramsey/uuid/blob/4.x/docs/README.md

Builds the documentation by running 'make html' inside the activated virtualenv. Requires the virtualenv from the previous setup step.

```bash
cd docs/
workon ramsey-uuid-docs
make html
```

--------------------------------

### Example Output of UUID Comparison

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/factory.rst

Shows the output from the previous example. The first UUID's bytes are rearranged according to ordered-time codec rules, while the second UUID's bytes remain in the same order as the UUID string.

```text
UUID: 2ff06620-6251-11ea-9791-0242ac130003
Bytes: 11ea62512ff0662097910242ac130003

UUID: 2ff09730-6251-11ea-ba64-0242ac130003
Bytes: 2ff09730625111eaba640242ac130003
```

--------------------------------

### Run tests inside VM

Source: https://github.com/ramsey/uuid/blob/4.x/resources/vagrant/windows/README.md

Once inside the VM, refresh environment, install dependencies, and run tests.

```bash
refreshenv
cd uuid
composer install
composer run-script --timeout=0 test
```

--------------------------------

### Convert GUID string to UUID with Uuid::fromString

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Takes the GUID string from the previous example and converts it to a standard RFC 9562 UUID using Uuid::fromString. The resulting UUID string is identical to the GUID string, but the byte order differs.

```php
$uuid = Uuid::fromString($guid->toString());

printf(
    "Class: %s\nUUID: %s\nVersion: %d\nBytes: %s\n",
    get_class($uuid),
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    bin2hex($uuid->getBytes())
);
```

--------------------------------

### Set StringCodec on UuidFactory

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Codecs

Shows how to create a UuidFactory and set a StringCodec (the default) as an example of changing the codec. This is not necessary for default behavior.

```php
namespace Ramsey\Uuid;

$factory = new UuidFactory();

$codec = new Codec\StringCodec(
    $factory->getUuidBuilder()
);

$factory->setCodec($codec);

$uuid = $factory->uuid1();
```

--------------------------------

### Method that calls Uuid::uuid1()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/testing.rst

Example method that uses the static Uuid::uuid1() method to get a UUID and format its date time. This is the method that needs to be tested.

```php
public function tellTime(): string
{
    $uuid = Uuid::uuid1();

    return $uuid->getDateTime()->format('Y-m-d H:i:s');
}
```

--------------------------------

### Uuid::uuid4()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Generates a Version 4 (random) UUID. This is the quickest way to get started with ramsey/uuid.

```APIDOC
## Uuid::uuid4()

### Description
Generates a Version 4 (random) UUID.

### Method
`Uuid::uuid4()`

### Parameters
None.

### Return Value
Returns an instance of `Ramsey\Uuid\Rfc4122\UuidV4`.

### Example
```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid4();

printf(
    "UUID: %s\nVersion: %d\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion()
);
```
```

--------------------------------

### Method accepting UuidInterface

Source: https://github.com/ramsey/uuid/blob/4.x/docs/testing.rst

Example method that accepts a UuidInterface and returns a formatted date-time string.

```php
public function tellTime(UuidInterface $uuid): string
{
    return $uuid->getDateTime()->format('Y-m-d H:i:s');
}
```

--------------------------------

### Method with UuidV1 type hint

Source: https://github.com/ramsey/uuid/blob/4.x/docs/testing.rst

Example method that uses a UuidV1 type hint and returns a formatted date string from the UUID's date-time.

```php
public function tellTime(UuidV1 $uuid): string
{
    return $uuid->getDateTime()->format('Y-m-d H:i:s');
}
```

--------------------------------

### Sample output for default version 2 UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version2.rst

Example output from the previous PHP script, showing the generated UUID fields. The output includes the UUID string, version, date, node, domain, and ID.

```text
UUID: 000001f5-5e9a-21ea-9e00-0242ac130003
Version: 2
Date: Thu, 05 Mar 2020 04:30:10 +0000
Node: 0242ac130003
Domain: person
ID: 501
```

--------------------------------

### Use RandomLibAdapter with high-strength generator

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Cookbook

Configure ramsey/uuid to use ircmaxell/random-lib with a high-strength generator. Requires creating a RandomLib\Factory and getting a high-strength generator to pass to RandomLibAdapter.

```php
$randomLibFactory = new \RandomLib\Factory();
$randomLibGenerator = $randomLibFactory->getHighStrengthGenerator();
$uuidFactory = new \Ramsey\Uuid\UuidFactory();
$uuidFactory->setRandomGenerator(
    new \Ramsey\Uuid\Generator\RandomLibAdapter($randomLibGenerator)
);

$uuid = \Ramsey\Uuid\Uuid::uuid4();
```

--------------------------------

### Create a custom calculator adapter implementing CalculatorInterface

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/calculators.rst

Define a class that wraps an external calculator and implements Ramsey\Uuid\Math\CalculatorInterface. The example shows the add method delegating to the internal calculator and returning an IntegerObject. The class is truncated for brevity in the source.

```php
namespace MyProject;

use Other\OtherCalculator;
use Ramsey\Uuid\Math\CalculatorInterface;
use Ramsey\Uuid\Type\Integer as IntegerObject;
use Ramsey\Uuid\Type\NumberInterface;

class MyUuidCalculator implements CalculatorInterface
{
    private $internalCalculator;

    public function __construct(OtherCalculator $customCalculator)
    {
        $this->internalCalculator = $customCalculator;
    }

    public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface
    {
        $value = $augend->toString();

        foreach ($addends as $addend) {
            $value = $this->internalCalculator->plus($value, $addend->toString());
        }

        return new IntegerObject($value);
    }

    /* ... Class truncated for brevity ... */

}
```

--------------------------------

### UUID byte arrangement

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/guid.rst

Shows the byte arrangement of the UUID from the conversion example, in big-endian order.

```text
fc 93 ab 0e c9 9e 4b 58 97 5e 9c 5e 68 c5 36 24
```

--------------------------------

### Example output of version 8 UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version8.rst

Sample output showing the generated UUID string and version number. The version is 8 and the UUID has the variant bits set.

```text
UUID: 00112233-4455-8677-8899-aabbccddeeff
Version: 8
```

--------------------------------

### Example output of timestamp-first COMB UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/timestamp-first-comb-codec.rst

Sample output showing the generated UUID string, version, and bytes. The bytes are in the same order as the string representation, allowing either to be stored and sorted.

```text
UUID: 9009ebcc-cd99-4b5f-90cf-9155607d2de9
Version: 4
Bytes: 9009ebcccd994b5f90cf9155607d2de9
```

--------------------------------

### Output of parsing nonstandard UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/other.rst

Shows the expected output when running the PHP example, with version 0 and variant 7.

```text
Class: Ramsey\Uuid\Nonstandard\Uuid
UUID: d95959bc-2ff5-43eb-fccd-14883ba8f174
Version: 0
Variant: 7
```

--------------------------------

### Generate a version 2 UUID with default settings

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version2.rst

Creates a version 2 UUID using the DCE_DOMAIN_PERSON domain. The example prints the UUID string, version, date, node, domain name, and local identifier. The local identifier is automatically obtained from the local machine as a POSIX UID.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid2(Uuid::DCE_DOMAIN_PERSON);

printf(
    "UUID: %s\nVersion: %d\nDate: %s\nNode: %s\nDomain: %s\nID: %s\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    $uuid->getDateTime()->format('r'),
    $uuid->getFields()->getNode()->toString(),
    $uuid->getLocalDomainName(),
    $uuid->getLocalIdentifier()->toString()
);
```

--------------------------------

### Use PeclUuidRandomGenerator for version 4 UUIDs

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Cookbook

Configure ramsey/uuid to use the PECL UUID extension for generating random bytes. Requires the UUID extension to be installed.

```php
$uuidFactory = new \Ramsey\Uuid\UuidFactory();
$uuidFactory->setRandomGenerator(new \Ramsey\Uuid\Generator\PeclUuidRandomGenerator());
\Ramsey\Uuid\Uuid::setFactory($uuidFactory);

$uuid = \Ramsey\Uuid\Uuid::uuid4();
```

--------------------------------

### getFields()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/guid-guid.rst

Returns the fields that comprise this GUID. This method is provided by the Guid class in addition to the methods defined on the UuidInterface.

```APIDOC
## getFields()

### Description
Returns the fields that comprise this GUID.

### Method
getFields()

### Returns
- **Return type:** `Ramsey\Uuid\Guid\Fields`
- **Description:** The fields that comprise this GUID.
```

--------------------------------

### Generate a version 1 UUID with default node

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version1.rst

Uses Uuid::uuid1() to create a version 1 UUID. The library attempts to use the machine's MAC address as the node; if not found, it generates a random node. The example prints the UUID string, version, creation date, and node.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid1();

printf(
    "UUID: %s\nVersion: %d\nDate: %s\nNode: %s\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    $uuid->getDateTime()->format('r'),
    $uuid->getFields()->getNode()->toString()
);
```

--------------------------------

### Generate a version 2 UUID with custom local ID, node, and clock sequence

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version2.rst

Creates a version 2 UUID with a custom local identifier (1001), a static node provider (MAC address 121212121212), and a clock sequence of 63. This example shows how to provide custom values for version 2 UUIDs.

```php
use Ramsey\Uuid\Provider\Node\StaticNodeProvider;
use Ramsey\Uuid\Type\Hexadecimal;
use Ramsey\Uuid\Type\Integer;
use Ramsey\Uuid\Uuid;

$localId = new Integer(1001);
$nodeProvider = new StaticNodeProvider(new Hexadecimal('121212121212'));
$clockSequence = 63;

$uuid = Uuid::uuid2(
    Uuid::DCE_DOMAIN_ORG,
    $localId,
    $nodeProvider->getNode(),
    $clockSequence
);
```

--------------------------------

### Set Rfc4122Validator on UuidFactory

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/validators.rst

Configures ramsey/uuid to use the Rfc4122Validator for stricter validation. The example creates a UuidFactory, sets the validator, and assigns the factory to the Uuid class. Then it checks a UUID string that is not RFC-compliant and prints a message.

```php
use Ramsey\Uuid\Rfc4122\Validator as Rfc4122Validator;
use Ramsey\Uuid\Uuid;
use Ramsey\Uuid\UuidFactory;

$factory = new UuidFactory();
$factory->setValidator(new Rfc4122Validator());

Uuid::setFactory($factory);

if (!Uuid::isValid('2bfb5006-087b-9553-5082-e8f39337ad29')) {
    echo "This UUID is not valid!\n";
}
```

--------------------------------

### Composer commands to replace rhumsaa/uuid with ramsey/uuid

Source: https://github.com/ramsey/uuid/blob/4.x/docs/faq.rst

Commands to remove the abandoned rhumsaa/uuid package and install ramsey/uuid version ^2.9. After running these, the namespace remains Rhumsaa, so no code changes are needed.

```bash
composer remove rhumsaa/uuid
composer require ramsey/uuid=^2.9
```

--------------------------------

### Generate a UUID with Uuid::uuid4()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Use the static method Uuid::uuid4() to generate a random (version 4) UUID. The example prints the UUID string and its version number. The returned instance is of type Ramsey\Uuid\Rfc4122\UuidV4.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid4();

printf(
    "UUID: %s\nVersion: %d\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion()
);
```

--------------------------------

### Example nonstandard UUID string

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/other.rst

A string that looks like a UUID but has variant bits that do not match RFC 9562/4122.

```text
d95959bc-2ff5-43eb-fccd-14883ba8f174
```

--------------------------------

### Use PECL UUID extension for time-based UUIDs

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Cookbook

Configure the UuidFactory to use PeclUuidTimeGenerator when the PECL UUID extension is installed. This replaces the library's system time values with those from the extension.

```php
$uuidFactory = new \Ramsey\Uuid\UuidFactory();
$uuidFactory->setTimeGenerator(new \Ramsey\Uuid\Generator\PeclUuidTimeGenerator());
\Ramsey\Uuid\Uuid::setFactory($uuidFactory);

$uuid = \Ramsey\Uuid\Uuid::uuid1();
```

--------------------------------

### Open built documentation in browser

Source: https://github.com/ramsey/uuid/blob/4.x/docs/README.md

Opens the generated HTML index file in the default browser after the build completes.

```bash
open _build/html/index.html
```

--------------------------------

### List available Composer commands

Source: https://github.com/ramsey/uuid/blob/4.x/CONTRIBUTING.md

Displays all commands available for contributing to the project.

```bash
composer list
```

--------------------------------

### Get optimized UUID bytes

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Codecs

Retrieves the binary representation of the ordered-time UUID, which is optimized for storage.

```php
$orderedTimeUuid->getBytes()
```

--------------------------------

### Configure and use the custom calculator with FeatureSet and UuidFactory

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/calculators.rst

Instantiate the custom calculator wrapper, set it on a FeatureSet, and pass the FeatureSet to a UuidFactory. Then generate a UUID with uuid1() using the custom calculator.

```php
use MyProject\MyUuidCalculator;
use Other\OtherCalculator;
use Ramsey\Uuid\FeatureSet;
use Ramsey\Uuid\UuidFactory;

$otherCalculator = new OtherCalculator();
$myUuidCalculator = new MyUuidCalculator($otherCalculator);

$featureSet = new FeatureSet();
$featureSet->setCalculator($myUuidCalculator);

$factory = new UuidFactory($featureSet);

$uuid = $factory->uuid1();
```

--------------------------------

### Get human-readable UUID string

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Codecs

Retrieves the standard string representation of the ordered-time UUID, either via toString() or casting to string.

```php
$orderedTimeUuid->toString()
(string) $orderedTimeUuid
```

--------------------------------

### Run static analysis

Source: https://github.com/ramsey/uuid/blob/4.x/CONTRIBUTING.md

Manually run PHPStan static analysis across the entire codebase.

```bash
# Static analysis
composer dev:analyze
```

--------------------------------

### Run all tests and coding standards checks

Source: https://github.com/ramsey/uuid/blob/4.x/CONTRIBUTING.md

Executes the full test suite and coding standards checks. Must pass before a pull request is accepted; failure results in a complete build failure.

```bash
composer test
```

--------------------------------

### Get UUID validation patterns using GenericValidator and Rfc4122Validator

Source: https://github.com/ramsey/uuid/blob/4.x/docs/upgrading/3-to-4.rst

Replacement for deprecated Uuid::VALID_PATTERN. Instantiates validators to retrieve the generic and RFC 4122 patterns.

```php
use Ramsey\Uuid\Validator\GenericValidator;
use Ramsey\Uuid\Rfc4122\Validator as Rfc4122Validator;

$genericPattern = (new GenericValidator())->getPattern();
$rfc4122Pattern = (new Rfc4122Validator())->getPattern();
```

--------------------------------

### Compare UUIDs from Configured Factory and Default Static Method

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/factory.rst

Generates a UUID using the configured factory and another using the static Uuid::uuid1() method, then prints both UUID strings and their byte representations. The output shows that the factory-generated UUID has reordered bytes while the static method uses the default order.

```php
$orderedTimeUuid = $factory->uuid1();

printf(
    "UUID: %s\nBytes: %s\n\n",
    $orderedTimeUuid->toString(),
    bin2hex($orderedTimeUuid->getBytes())
);

$uuid = Uuid::uuid1();

printf(
    "UUID: %s\nBytes: %s\n\n",
    $uuid->toString(),
    bin2hex($uuid->getBytes())
);
```

--------------------------------

### Use RandomLibAdapter with default medium-strength generator

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Cookbook

Configure ramsey/uuid to use ircmaxell/random-lib for generating random bytes. By default, RandomLibAdapter uses a medium-strength generator.

```php
$uuidFactory = new \Ramsey\Uuid\UuidFactory();
$uuidFactory->setRandomGenerator(new \Ramsey\Uuid\Generator\RandomLibAdapter());
\Ramsey\Uuid\Uuid::setFactory($uuidFactory);

$uuid = \Ramsey\Uuid\Uuid::uuid4();
```

--------------------------------

### Generate a version 7 UUID with current time

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version7.rst

Uses Uuid::uuid7() to create a version 7 UUID and prints its string representation, version, and creation date. The output shows a sample UUID and date.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid7();

printf(
    "UUID: %s\nVersion: %d\nDate: %s\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    $uuid->getDateTime()->format('r'),
);
```

```text
UUID: 01833ce0-3486-7bfd-84a1-ad157cf64005
Version: 7
Date: Wed, 14 Sep 2022 16:41:10 +0000
```

--------------------------------

### FallbackNodeProvider constructor usage

Source: https://github.com/ramsey/uuid/blob/4.x/docs/upgrading/3-to-4.rst

Shows how to instantiate FallbackNodeProvider with an iterable of NodeProviderInterface instances. The constructor now requires this iterable parameter.

```php
use MyPackage\MyCustomNodeProvider;
use Ramsey\Uuid\Provider\Node\FallbackNodeProvider;
use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
use Ramsey\Uuid\Provider\Node\SystemNodeProvider;

$nodeProviders = [];
$nodeProviders[] = new MyCustomNodeProvider();
$nodeProviders[] = new SystemNodeProvider();
$nodeProviders[] = new RandomNodeProvider();

$provider = new FallbackNodeProvider($nodeProviders);
```

--------------------------------

### Generate a version 6 UUID with Uuid::uuid6()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version6.rst

Creates a version 6 UUID using the default node and clock sequence. Prints the UUID string, version, creation date, and node. The output shows a sample result.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid6();

printf(
    "UUID: %s\nVersion: %d\nDate: %s\nNode: %s\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    $uuid->getDateTime()->format('r'),
    $uuid->getFields()->getNode()->toString()
);
```

```text
UUID: 1ea60f56-b67b-61fc-829a-0242ac130003
Version: 6
Date: Sun, 08 Mar 2020 04:29:37 +0000
Node: 0242ac130003
```

--------------------------------

### Configure UuidFactory with OrderedTimeCodec

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/factory.rst

Creates a new UuidFactory and sets an OrderedTimeCodec using the factory's UUID builder. This configuration only affects the factory instance, not the static Uuid methods.

```php
use Ramsey\Uuid\Codec\OrderedTimeCodec;
use Ramsey\Uuid\UuidFactory;

$factory = new UuidFactory();
$codec = new OrderedTimeCodec($factory->getUuidBuilder());

$factory->setCodec($codec);

$orderedTimeUuid = $factory->uuid1();
```

--------------------------------

### getVersion()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/rfc4122-fieldsinterface.rst

Returns the UUID version.

```APIDOC
## getVersion()

### Description
Returns the UUID version.

### Method
`getVersion()`

### Returns
- **Type**: `int`
- **Description**: The UUID version.
```

--------------------------------

### Create notes table with char(36) UUID column

Source: https://github.com/ramsey/uuid/blob/4.x/docs/database.rst

SQL to create a table for storing UUIDs as strings. Uses a char(36) column for the UUID and a text column for notes. This is the simplest approach but consumes more space.

```sql
CREATE TABLE `notes` (
    `uuid` char(36) NOT NULL,
    `notes` text NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

--------------------------------

### fromUuidV1()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/nonstandard-uuidv6.rst

Static factory method that creates a version 6 UUID from a given version 1 UUID.

```APIDOC
## fromUuidV1()

### Description
Static factory method that creates a version 6 UUID from a given version 1 UUID.

### Method
fromUuidV1()

### Parameters
- **$uuidV1** (`Ramsey\Uuid\Rfc4122\UuidV1`) - Required - A version 1 UUID.

### Returns
- **Type**: `Ramsey\Uuid\Rfc4122\UuidV6`
- **Description**: A version 6 UUID, converted from the given version 1 UUID.

```

--------------------------------

### Composer command to allow version 3 or 4

Source: https://github.com/ramsey/uuid/blob/4.x/docs/upgrading/3-to-4.rst

Use this command to require ramsey/uuid version 3 or 4 in your project, allowing downstream users to continue using your project while they upgrade.

```bash
composer require ramsey/uuid:"^3 || ^4"
```

--------------------------------

### Test using Uuid::uuid1()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/testing.rst

PHPUnit test that creates a UuidV1 instance with Uuid::uuid1() and asserts the method returns a string.

```php
public function testTellTime(): void
{
    $uuid = Uuid::uuid1();
    $myObj = new MyClass();

    $this->assertIsString($myObj->tellTime($uuid));
}
```

--------------------------------

### Convert node field to BigInteger using Brick\Math

Source: https://github.com/ramsey/uuid/blob/4.x/docs/upgrading/3-to-4.rst

Shows how to use brick/math to convert the node field from the UUID fields to a BigInteger, as a replacement for deprecated methods that returned int or BigNumber.

```php
use Brick\Math\BigInteger;

$node = BigInteger::fromBase($uuid->getFields()->getNode()->toString(), 16);
```

--------------------------------

### Configure TimestampFirstCombCodec and generate a version 4 UUID

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/timestamp-first-comb-codec.rst

Sets up a UuidFactory with TimestampFirstCombCodec and CombGenerator, then generates a version 4 UUID and prints its string, version, and bytes. The codec is deprecated; migrate to version 7 Unix Epoch time UUIDs.

```php
use Ramsey\Uuid\Codec\TimestampFirstCombCodec;
use Ramsey\Uuid\Generator\CombGenerator;
use Ramsey\Uuid\UuidFactory;

$factory = new UuidFactory();
$codec = new TimestampFirstCombCodec($factory->getUuidBuilder());

$factory->setCodec($codec);

$factory->setRandomGenerator(new CombGenerator(
    $factory->getRandomGenerator(),
    $factory->getNumberConverter()
));

$timestampFirstComb = $factory->uuid4();

printf(
    "UUID: %s\nVersion: %d\nBytes: %s\n",
    $timestampFirstComb->toString(),
    $timestampFirstComb->getFields()->getVersion(),
    bin2hex($timestampFirstComb->getBytes())
);
```

--------------------------------

### Uuid::fromBytes()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Creates a UUID instance from a 16-byte string.

```APIDOC
## Uuid::fromBytes()

### Description
Creates a UUID instance from a 16-byte string.

### Method
`Uuid::fromBytes()`

### Parameters
- **bytes** (string) - Required - The 16-byte string.

### Return Value
Returns a UUID instance.
```

--------------------------------

### fromBytes($bytes)

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuid.rst

Creates an instance of UuidInterface from a 16-byte binary string representation of a UUID.

```APIDOC
## fromBytes($bytes)

### Description
Creates an instance of UuidInterface from a 16-byte string.

### Method
Static method

### Parameters
- **$bytes** (`string`) - Required - A 16-byte binary string representation of a UUID

### Return Type
`Ramsey\Uuid\UuidInterface`
```

--------------------------------

### Test using custom factory to return specific UUIDs

Source: https://github.com/ramsey/uuid/blob/4.x/docs/testing.rst

Test method that replaces the default factory with the custom test factory and sets the uuid1 property to specific UUID values to assert the output of the tellTime() method. Must run in a separate process to avoid affecting other tests.

```php
/**
 * @runInSeparateProcess
 * @preserveGlobalState disabled
 */
public function testTellTime(): void
{
    $factory = new MyTestUuidFactory();
    Uuid::setFactory($factory);

    $myObj = new MyClass();

    $factory->uuid1 = Uuid::fromString('177ef0d8-6630-11ea-b69a-0242ac130003');
    $this->assertSame('2020-03-14 20:12:12', $myObj->tellTime());

    $factory->uuid1 = Uuid::fromString('13814000-1dd2-11b2-9669-00007ffffffe');
    $this->assertSame('1970-01-01 00:00:00', $myObj->tellTime());
}
```

--------------------------------

### __toString()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuidinterface.rst

Returns the string standard representation of the UUID.

```APIDOC
## __toString()

### Description
Returns the string standard representation of the UUID.

### Method
__toString

### Returns
- **string** - The string standard representation of the UUID.
```

--------------------------------

### toString()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuidinterface.rst

Returns the string standard representation of the UUID.

```APIDOC
## toString()

### Description
Returns the string standard representation of the UUID.

### Method
toString

### Returns
- **string** - The string standard representation of the UUID.
```

--------------------------------

### Parse nonstandard UUID with Uuid::fromString()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/nonstandard/other.rst

Creates a Ramsey\Uuid\Nonstandard\Uuid from the given string and prints class, UUID, version, and variant.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::fromString('d95959bc-2ff5-43eb-fccd-14883ba8f174');

printf(
    "Class: %s\nUUID: %s\nVersion: %d\nVariant: %s\n",
    get_class($uuid),
    $uuid->toString(),
    $uuid->getFields()->getVersion(),
    $uuid->getFields()->getVariant()
);
```

--------------------------------

### Create custom random generator implementing RandomGeneratorInterface

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Cookbook

Define a custom random generator class that implements RandomGeneratorInterface. The generate method must return $length bytes of data.

```php
namespace MyVendor\Uuid;

class MyRandomGenerator implements \Ramsey\Uuid\Generator\RandomGeneratorInterface
{
    public function generate($length)
    {
        // Your code to generate $length bytes of data
        return $bytes;
    }
}
```

--------------------------------

### compareTo($other)

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuidinterface.rst

Compares this UUID to another UUID and returns -1, 0, or 1 depending on the order.

```APIDOC
## compareTo($other)

### Description
Compares this UUID to another UUID.

### Method
compareTo

### Parameters
- **$other** (Ramsey\Uuid\UuidInterface) - Required - The UUID to compare

### Returns
- **int** - Returns `-1`, `0`, or `1` if the UUID is less than, equal to, or greater than the other UUID.
```

--------------------------------

### Convert version 1 UUID to version 6 using UuidV6::fromUuidV1

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version6.rst

Converts a version 1 UUID string to a version 6 UUID. Requires the UUID to be an instance of UuidV1. Uses Ramsey\Uuid\Uuid::fromString and UuidV6::fromUuidV1.

```php
use Ramsey\Uuid\Rfc4122\UuidV1;
use Ramsey\Uuid\Rfc4122\UuidV6;
use Ramsey\Uuid\Uuid;

$uuid1 = Uuid::fromString('3960c5d8-60f8-11ea-bc55-0242ac130003');

if ($uuid1 instanceof UuidV1) {
    $uuid6 = UuidV6::fromUuidV1($uuid1);
}
```

--------------------------------

### Set OrderedTimeCodec on UuidFactory

Source: https://github.com/ramsey/uuid/wiki/Ramsey\Uuid-Codecs

Shows how to use OrderedTimeCodec to re-arrange the timestamp part of the UUID for optimized storage in InnoDB.

```php
namespace Ramsey\Uuid;

$factory = new UuidFactory();

$codec = new Codec\OrderedTimeCodec(
    $factory->getUuidBuilder()
);

$factory->setCodec($codec);

$orderedTimeUuid = $factory->uuid1();
```

--------------------------------

### Uuid::fromString()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Creates a UUID instance from a string UUID.

```APIDOC
## Uuid::fromString()

### Description
Creates a UUID instance from a string UUID.

### Method
`Uuid::fromString()`

### Parameters
- **uuid** (string) - Required - The string UUID.

### Return Value
Returns a UUID instance.
```

--------------------------------

### fromString($uuid)

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuid.rst

Creates an instance of UuidInterface from the string standard representation of a UUID.

```APIDOC
## fromString($uuid)

### Description
Creates an instance of UuidInterface from the string standard representation.

### Method
Static method

### Parameters
- **$uuid** (`string`) - Required - The string standard representation of a UUID

### Return Type
`Ramsey\Uuid\UuidInterface`
```

--------------------------------

### Generate a version 1 UUID with custom node and clock sequence

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version1.rst

Uses StaticNodeProvider and Hexadecimal to set a custom node, and provides a custom clock sequence value. This allows control over the node and clock sequence for version 1 UUIDs.

```php
use Ramsey\Uuid\Provider\Node\StaticNodeProvider;
use Ramsey\Uuid\Type\Hexadecimal;
use Ramsey\Uuid\Uuid;

$nodeProvider = new StaticNodeProvider(new Hexadecimal('121212121212'));
$clockSequence = 16383;

$uuid = Uuid::uuid1($nodeProvider->getNode(), $clockSequence);
```

--------------------------------

### Create notes table with char(16) UUID column

Source: https://github.com/ramsey/uuid/blob/4.x/docs/database.rst

SQL to create a table with a char(16) column for storing UUID bytes, saving space compared to char(36).

```sql
CREATE TABLE `notes` (
    `uuid` char(16) NOT NULL,
    `notes` text NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

--------------------------------

### Uuid::uuid7()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Generates a Version 7 (Unix Epoch Time) UUID.

```APIDOC
## Uuid::uuid7()

### Description
Generates a Version 7 (Unix Epoch Time) UUID.

### Method
`Uuid::uuid7()`

### Parameters
None.

### Return Value
Returns a UUID instance.
```

--------------------------------

### CalculatorInterface::fromBase

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/calculators.rst

Converts a value from an arbitrary base to a base-10 integer value.

```APIDOC
## CalculatorInterface::fromBase

### Description
Converts a value from an arbitrary base to a base-10 integer value.

### Method
fromBase

### Signature
`fromBase($value, $base)`

### Parameters
- **$value** (string) - Required - The value to convert
- **$base** (int) - Required - The base to convert from (i.e., 2, 16, 32, etc.)

### Returns
- **Type**: Ramsey\Uuid\Type\Integer
- **Description**: The base-10 integer value of the converted value
```

--------------------------------

### uuid5($ns, $name)

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuid.rst

Generates a version 5, name-based (SHA-1) UUID. This method takes a namespace and a name, and returns a version 5 UUID.

```APIDOC
## uuid5($ns, $name)

### Description
Generates a version 5, name-based (SHA-1) UUID.

### Method
Static method

### Parameters
- **$ns** (`Ramsey\Uuid\UuidInterface|string`) - Required - The namespace for this identifier
- **$name** (`string`) - Required - The name from which to generate an identifier

### Returns
A version 5 UUID

### Return Type
`Ramsey\Uuid\Rfc4122\UuidV5`
```

--------------------------------

### Create table with UUID unique key

Source: https://github.com/ramsey/uuid/blob/4.x/docs/database.rst

SQL to create a notes table with an auto-increment primary key and a unique key on a char(36) UUID column, as recommended when not using UUIDs as the primary key.

```sql
CREATE TABLE `notes` (
    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
    `uuid` char(36) NOT NULL,
    `notes` text NOT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `notes_uuid_uk` (`uuid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```

--------------------------------

### Ramsey\Uuid\v3

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/helper.rst

Generates a string standard representation of a version 3, name-based (MD5) UUID.

```APIDOC
## Ramsey\\Uuid\\v3

### Description
Generates a string standard representation of a version 3, name-based (MD5) UUID.

### Method
Function

### Signature
`Ramsey\Uuid\v3($ns, $name)`

### Parameters
- **$ns** (`Ramsey\Uuid\UuidInterface|string`) - Required - The namespace for this identifier
- **$name** (`string`) - Required - The name from which to generate an identifier

### Returns
- **Type:** `string`
- **Description:** A string standard representation of a version 3 UUID
```

--------------------------------

### CalculatorInterface::toBase

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/calculators.rst

Converts a base-10 integer value to an arbitrary base.

```APIDOC
## CalculatorInterface::toBase

### Description
Converts a base-10 integer value to an arbitrary base.

### Method
toBase

### Signature
`toBase($value, $base)`

### Parameters
- **$value** (Ramsey\Uuid\Type\Integer) - Required - The integer value to convert
- **$base** (int) - Required - The base to convert to (i.e., 2, 16, 32, etc.)

### Returns
- **Type**: string
- **Description**: The value represented in the specified base
```

--------------------------------

### Uuid::uuid3()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/quickstart.rst

Generates a Version 3 (Name-based MD5) UUID.

```APIDOC
## Uuid::uuid3()

### Description
Generates a Version 3 (Name-based MD5) UUID.

### Method
`Uuid::uuid3()`

### Parameters
None.

### Return Value
Returns a UUID instance.
```

--------------------------------

### Ramsey\Uuid\v7

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/helper.rst

Generates a string standard representation of a version 7, Unix Epoch time UUID.

```APIDOC
## Ramsey\\Uuid\\v7

### Description
Generates a string standard representation of a version 7, Unix Epoch time UUID.

### Method
Function

### Signature
`Ramsey\Uuid\v7([$dateTime])`

### Parameters
- **$dateTime** (`\DatetimeInterface|null`) - Optional - An optional date/time from which to create the version 7 UUID. If not provided, the UUID is generated using the current date/time

### Returns
- **Type:** `string`
- **Description:** A string standard representation of a version 7 UUID
```

--------------------------------

### toUuidV1()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/nonstandard-uuidv6.rst

Converts this version 6 UUID to a version 1 UUID.

```APIDOC
## toUuidV1()

### Description
Converts this version 6 UUID to a version 1 UUID.

### Method
toUuidV1()

### Returns
- **Type**: `Ramsey\Uuid\Rfc4122\UuidV1`
- **Description**: A version 1 UUID, converted from this version 6 UUID.

```

--------------------------------

### Convert version 6 UUID to version 1 using toUuidV1

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version6.rst

Converts a version 6 UUID string back to a version 1 UUID. Requires the UUID to be an instance of UuidV6. Uses Uuid::fromString and the toUuidV1 method.

```php
use Ramsey\Uuid\Rfc4122\UuidV6;
use Ramsey\Uuid\Uuid;

$uuid6 = Uuid::fromString('1ea60f83-960c-65d8-bc55-0242ac130003');

if ($uuid6 instanceof UuidV6) {
    $uuid1 = $uuid6->toUuidV1();
}
```

--------------------------------

### getTimestamp()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/rfc4122-fieldsinterface.rst

Returns the full 60-bit timestamp, without the version.

```APIDOC
## getTimestamp()

### Description
Returns the full 60-bit timestamp, without the version.

### Method
`getTimestamp()`

### Returns
- **Type**: `Ramsey\Uuid\Type\Hexadecimal`
- **Description**: The full 60-bit timestamp, without the version.
```

--------------------------------

### getUrn()

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuidinterface.rst

Returns the string standard representation of the UUID as a URN.

```APIDOC
## getUrn()

### Description
Returns the string standard representation of the UUID as a URN.

### Method
getUrn

### Returns
- **string** - The string standard representation of the UUID as a URN.
```

--------------------------------

### Generate version 5 UUID with URL namespace

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version5.rst

Creates a version 5 UUID for a URL using the predefined URL namespace. The output is deterministic: for 'https://www.php.net' it always returns 'a8f6ae40-d8a7-58f0-be05-a22f94eca9ec'. The result is an instance of UuidV5.

```php
use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid5(Uuid::NAMESPACE_URL, 'https://www.php.net');
```

--------------------------------

### fromInteger($integer)

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/uuid.rst

Creates an instance of UuidInterface from a 128-bit string integer representation of a UUID.

```APIDOC
## fromInteger($integer)

### Description
Creates an instance of UuidInterface from a 128-bit string integer.

### Method
Static method

### Parameters
- **$integer** (`string`) - Required - A 128-bit string integer representation of a UUID

### Return Type
`Ramsey\Uuid\UuidInterface`
```

--------------------------------

### Generate ordered-time UUID with OrderedTimeCodec

Source: https://github.com/ramsey/uuid/blob/4.x/docs/customize/ordered-time-codec.rst

Configures a UuidFactory with the OrderedTimeCodec and generates a version 1 UUID, printing its string, version, date, node, and bytes. The byte representation is rearranged for sorting, while the string representation remains standard.

```php
use Ramsey\Uuid\Codec\OrderedTimeCodec;
use Ramsey\Uuid\UuidFactory;

$factory = new UuidFactory();
$codec = new OrderedTimeCodec($factory->getUuidBuilder());

$factory->setCodec($codec);

$orderedTimeUuid = $factory->uuid1();

printf(
    "UUID: %s\nVersion: %d\nDate: %s\nNode: %s\nBytes: %s\n",
    $orderedTimeUuid->toString(),
    $orderedTimeUuid->getFields()->getVersion(),
    $orderedTimeUuid->getDateTime()->format('r'),
    $orderedTimeUuid->getFields()->getNode()->toString(),
    bin2hex($orderedTimeUuid->getBytes())
);
```

```text
UUID: 593200aa-61ae-11ea-bbf2-0242ac130003
Version: 1
Date: Mon, 09 Mar 2020 02:33:23 +0000
Node: 0242ac130003
Bytes: 11ea61ae593200aabbf20242ac130003
```

--------------------------------

### Ramsey\Uuid\v5

Source: https://github.com/ramsey/uuid/blob/4.x/docs/reference/helper.rst

Generates a string standard representation of a version 5, name-based (SHA-1) UUID.

```APIDOC
## Ramsey\\Uuid\\v5

### Description
Generates a string standard representation of a version 5, name-based (SHA-1) UUID.

### Method
Function

### Signature
`Ramsey\Uuid\v5($ns, $name)`

### Parameters
- **$ns** (`Ramsey\Uuid\UuidInterface|string`) - Required - The namespace for this identifier
- **$name** (`string`) - Required - The name from which to generate an identifier

### Returns
- **Type:** `string`
- **Description:** A string standard representation of a version 5 UUID
```

--------------------------------

### Output of getNode()->toString() after StaticNodeProvider

Source: https://github.com/ramsey/uuid/blob/4.x/docs/rfc4122/version1.rst

Shows the node value after the unicast/multicast bit is set by StaticNodeProvider. The original custom node 121212121212 becomes 131212121212.

```text
131212121212
```
Tokens:
Raw