Java UUID Generator

https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/
Admin
Java UUID Generator is a FasterXML library for generating various types of UUIDs (Universally Unique...
Tokens:35,973
Snippets:436
Trust Score:9.5
Update:6 months ago
Show doc for...
Tokens:
Raw
### GET /generate

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedEpochGenerator.html

Generates a new UUID instance.

```APIDOC
## GET /generate

### Description
Method for generating a new UUID.

### Method
GET

### Response
#### Success Response (200)
- **UUID** (object) - Newly generated UUID instance.
```

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

### FileSyncTest Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/test/FileSyncTest.html

The default constructor for the FileSyncTest class. No specific setup is required to instantiate this class.

```java
public
FileSyncTest()
```

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

### Populate byte array from UUID with offset

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Populates a provided byte array with the byte representation of a UUID, starting at a specified offset.

```java
public static void toByteArray(UUID uuid,
                               byte[] buffer,
                               int offset)
```

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

### Create EthernetAddress from Preferred Interface

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Factory method to get the ethernet address of a preferred network interface. It attempts to find an interface with a suitable MAC address, prioritizing egress interfaces and then non-loopback interfaces.

```java
public static EthernetAddress fromPreferredInterface()
```

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

### Create Default Time-Based Generator

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Factory method for constructing a UUID generator using version 1 (time+location based). Uses the Ethernet address of the interface that routes to the default gateway or an indeterminately selected non-loopback interface. For complex network setups, consider using a generator with an explicitly specified address.

```java
public static TimeBasedGenerator defaultTimeBasedGenerator()
```

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

### Write EthernetAddress to Byte Array at Position

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Writes the 6-byte binary representation of the ethernet address into a provided byte array, starting at a specified position.

```java
public void toByteArray(byte[] array,
                        int pos)
```

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

### FileSyncTest Main Method

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/test/FileSyncTest.html

The entry point for the FileSyncTest utility. This method is designed to be executed manually for testing file synchronization. It can throw exceptions.

```java
public static void
main(String[] args)
throws Exception
```

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

### main Method

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/perf/MeasurePerformance.html

Entry point for the MeasurePerformance utility. This method may throw an Exception.

```java
public static void main(String[] args)
                 throws Exception
```

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

### Get Logger Instance

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/LoggerFacade.html

Retrieves a LoggerFacade instance for the specified class.

```java
public static LoggerFacade getLogger(Class<?> forClass)
```

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

### Jug Class Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

Lists the available methods for the Jug class, including main, printUsage, and run.

```java
static void
main(String[] args)
```

```java
protected void
printUsage()
```

```java
void
run(String[] args)
```

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

### Get UUID type

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDGenerator.html

Abstract method to determine the UUID version produced by the generator.

```java
public abstract UUIDType getType()
```

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

### Method Definitions

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedReorderedGenerator.html

Core methods for generating UUIDs, retrieving configuration, and manual construction.

```java
public UUIDType getType()
```

```java
public EthernetAddress getEthernetAddress()
```

```java
public UUID generate()
```

```java
public UUID construct(long rawTimestamp)
```

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

### Get Random Number Generator

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Helper method for accessing the configured random number generator.

```java
protected static Random _randomNumberGenerator()
```

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

### Jug Class - Constructor Details

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

Detailed information about the constructors of the Jug class.

```APIDOC
## Constructor Details

### Jug
```java
public Jug()
```

Default constructor for the Jug class.
```

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

### EthernetAddress Factory Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Static factory methods for creating EthernetAddress instances from different data formats.

```APIDOC
## static EthernetAddress valueOf(Object addr)

### Description
Constructs a new EthernetAddress from various input formats including String, byte array, int array, or long integer.

### Parameters
#### Request Body
- **addr** (String/byte[]/int[]/long) - Required - The representation of the ethernet address.

### Response
#### Success Response (200)
- **EthernetAddress** (Object) - The constructed EthernetAddress instance.

### Errors
- **NumberFormatException** - Thrown if the provided address format is invalid.
```

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

### UUIDTimer Protected Method: getAndSetTimestamp

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Protected method to get and set the timestamp within a byte array representing a UUID.

```java
protected final
void
getAndSetTimestamp(byte[]
uuidBytes)
```

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

### Get Clock Sequence

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Retrieves the current clock sequence value. This is part of the UUID generation process to ensure uniqueness.

```java
int getClockSequence()
```

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

### EthernetAddress Factory Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Methods for retrieving or constructing EthernetAddress instances.

```APIDOC
## GET /EthernetAddress/fromPreferredInterface

### Description
Locates a network interface with a suitable MAC address. It prioritizes egress interfaces and falls back to non-loopback interfaces.

### Method
GET

### Response
#### Success Response (200)
- **EthernetAddress** (object) - The address of the interface, or null if none found.

## GET /EthernetAddress/fromEgressInterface

### Description
Determines the ethernet address of the network interface that connects to the default network gateway.

### Method
GET

### Response
#### Success Response (200)
- **EthernetAddress** (object) - The address of the egress interface, or null if unsuccessful.

## POST /EthernetAddress/constructMulticastAddress

### Description
Constructs a random multicast address to be used when no real ethernet address is available.

### Method
POST

### Parameters
#### Request Body
- **rnd** (Random) - Optional - A specific random number generator instance.
```

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

### FileSyncTest Class

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/test/FileSyncTest.html

Documentation for the FileSyncTest class, a simple manual utility test class for checking file-based synchronization.

```APIDOC
## FileSyncTest Class

### Description
Simple manual utility test class for manually checking whether file-based synchronization seems to be working or not.

### Constructor Summary
Constructors Constructor and Description
---
`FileSyncTest()`

### Method Summary
All Methods Static Methods Concrete Methods Modifier and Type | Method and Description
--|--
`static void` | `main(String[] args)`

### Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail
#### FileSyncTest
```java
public FileSyncTest()
```

### Method Detail
#### main
```java
public static void main(String[] args)
                 throws Exception
```

Throws:
`Exception`
```

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

### RandomBasedGenerator Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/RandomBasedGenerator.html

Provides methods to get the UUID type and generate a new UUID. These methods are inherited from parent classes.

```java
public UUIDType getType()

public UUID generate()
```

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

### Get Max UUID

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Provides access to the 'Max' UUID, which is a UUID consisting of all ones, as defined in RFC 9562, Section 5.10.

```java
public static UUID maxUUID()
```

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

### EthernetAddress Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Methods for cloning, factory creation, and value conversion.

```java
public Object clone()
```

```java
public static EthernetAddress valueOf(byte[] addr)
                               throws NumberFormatException
```

```java
public static EthernetAddress valueOf(int[] addr)
                               throws NumberFormatException
```

```java
public static EthernetAddress valueOf(String addrStr)
                               throws NumberFormatException
```

```java
public static EthernetAddress valueOf(long addr)
```

```java
public static EthernetAddress fromInterface()
```

```java
public static EthernetAddress fromInterface(NetworkInterface nint)
```

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

### Get Nil UUID

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Provides access to the 'Nil' UUID, which is a UUID consisting of all zeroes, as defined in RFC 9562, Section 5.9.

```java
public static UUID nilUUID()
```

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

### Jug Class - Method Details

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

Detailed information about the methods within the Jug class.

```APIDOC
## Method Details

### printUsage
```java
protected void printUsage()
```

Prints the usage instructions for the command-line interface.

### main
```java
public static void main(String[] args)
```

Entry point for the command-line interface. Executes the UUID generation process based on the provided arguments.

### run
```java
public void run(String[] args)
```

Executes the UUID generation process with the given arguments.
```

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

### EthernetAddress Factory Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Methods for creating EthernetAddress instances from network interfaces or generating random multicast addresses.

```APIDOC
## Static Factory Methods

### Description
Methods to retrieve or generate EthernetAddress instances based on system network interfaces or random generation.

### Methods
- `fromEgressInterface()`: Determines the address of the interface connecting to the default gateway.
- `fromInterface()`: Locates a network interface with a suitable MAC address.
- `fromInterface(NetworkInterface nint)`: Returns the address of a specific network interface.
- `constructMulticastAddress()`: Generates a random multicast address.

### Response
- **EthernetAddress** (Object) - The constructed EthernetAddress instance.
```

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

### Get and Set Timestamp for UUID Bytes

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Internal method to retrieve and set the timestamp within the byte array representing the UUID.

```java
protected void getAndSetTimestamp(byte[] uuidBytes)
```

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

### fromLocalAddress Method

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Attempts to find the default egress network interface on the current system by matching a provided local address.

```APIDOC
## Method: fromLocalAddress

### Description
Attempts to find the default egress interface on the current system by finding a NetworkInterface that has the specified network address. If multiple interfaces match, one is selected indeterminately.

### Parameters
#### Path Parameters
- **localAddress** (InetAddress) - Required - The local address which is assigned to an interface.

### Returns
- **NetworkInterface** - The egress interface.

### Throws
- **EgressInterfaceFinder.EgressResolutionException** - If an egress interface could not be determined.
```

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

### Convert UUID to Byte Array with Offset

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Writes the 16-byte representation of a UUID into a provided byte array, starting at a specified offset.

```java
public static void toByteArray(UUID uuid,
            byte[] buffer)
```

```java
public static void toByteArray(UUID uuid,
            byte[] buffer,
            int offset)
```

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

### EgressInterfaceFinder.fromRootNameserverConnection

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Attempts to find the default egress interface by connecting to a random root name server with a specified timeout.

```APIDOC
## GET /api/egress/root-nameserver

### Description
Attempts to find the default egress interface on the current system, by connecting to one of the root name servers (chosen at random).

### Method
GET

### Endpoint
/api/egress/root-nameserver

### Parameters
#### Query Parameters
- **timeoutMillis** (int) - Required - The amount of time (milliseconds) allowed to establish an outbound connection

### Response
#### Success Response (200)
- **networkInterface** (NetworkInterface) - The egress interface

#### Response Example
```json
{
  "networkInterface": "eth0"
}
```

### Throws
- **EgressInterfaceFinder.EgressResolutionException** - if an egress interface could not be determined
```

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

### Create UUID from Byte Array with Offset

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Constructs a UUID instance from a byte array, starting at a specified offset. No validation is performed on the byte content.

```java
public static UUID uuid(byte[] bytes,
            int offset)
```

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

### UUID Utility Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Utility methods for handling byte arrays and initializing UUID components.

```APIDOC
## UUIDUtil

### Description
Provides utility methods for UUID operations.

### Methods

#### gatherLong(byte[] data, int offset)
- **Description**: Gathers a long value from a byte array at a specified offset.
- **Method**: N/A (Static method within a class)
- **Endpoint**: N/A

#### initUUIDFirstLong(long timestamp, UUIDType type)
- **Description**: Initializes the first long part of a UUID with a timestamp and type.
- **Method**: N/A (Static method within a class)
- **Endpoint**: N/A

#### initUUIDFirstLong(long timestamp, int type)
- **Description**: Initializes the first long part of a UUID with a timestamp and type (integer representation).
- **Method**: N/A (Static method within a class)
- **Endpoint**: N/A

#### initUUIDSecondLong(long clockSeqAndNode)
- **Description**: Initializes the second long part of a UUID with clock sequence and node information.
- **Method**: N/A (Static method within a class)
- **Endpoint**: N/A
```

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

### EthernetAddress Utility Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Methods for address conversion, validation, and comparison.

```APIDOC
## GET /EthernetAddress/asByteArray

### Description
Returns the 6-byte binary representation of the ethernet address.

### Method
GET

### Response
#### Success Response (200)
- **byte[]** (array) - 6-byte array representation.

## GET /EthernetAddress/isMulticastAddress

### Description
Checks if the address refers to a multicast address.

### Method
GET

### Response
#### Success Response (200)
- **boolean** (boolean) - True if multicast, false otherwise.

## GET /EthernetAddress/toString

### Description
Returns the canonical string representation (17 characters, lower-case).

### Method
GET

### Response
#### Success Response (200)
- **String** (string) - Canonical string representation.
```

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

### EthernetAddress Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Methods for interacting with EthernetAddress objects, including binary representation and multicast address construction.

```APIDOC
## EthernetAddress Methods

### asByteArray()
- **Description**: Returns a 6-byte array containing the binary representation of the Ethernet address.
- **Return**: byte[]

### constructMulticastAddress()
- **Description**: Factory method to construct a random multicast address.
- **Parameters**:
  - **random** (Random) - Optional - Random instance for address generation.
```

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

### Get String Representation of EthernetAddress

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Returns the canonical string representation of this ethernet address. The string is always lower-case and 17 characters long, including leading zeroes.

```java
public String toString()
```

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

### initialize

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/ext/FileBasedTimestampSynchronizer.html

Fetches the persisted timestamp value to ensure uniqueness across JVM incarnations.

```APIDOC
## initialize

### Description
This method is called once by UUIDTimer to fetch the persisted timestamp value, indicating the first timestamp guaranteed not to have been used by a previous incarnation.

### Method
protected long initialize()

### Response
- **Returns** (long) - First timestamp value not locked by lock files; 0L if no information was read.

### Throws
- **IOException** - If an I/O error occurs.
```

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

### UUIDClock Class

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDClock.html

The UUIDClock class is used by UUIDTimer to get the current time. It can be overridden to return custom time values for generating UUIDs with specific timestamps or for reproducible generation.

```APIDOC
## Class: UUIDClock

### Description
Used by UUIDTimer to get the current time. Can be overridden for custom time generation.

### Class Declaration
```java
public class UUIDClock
extends Object
```

### Constructor Summary
#### `UUIDClock()`
Default constructor.

### Method Summary
#### `long currentTimeMillis()`
Returns the current time in milliseconds.

#### `static UUIDClock systemTimeClock()`
Factory method to create a UUIDClock that uses the system clock.

### Constructor Detail
#### `UUIDClock()`
```java
public UUIDClock()
```

### Method Detail
#### `systemTimeClock()`
```java
public static UUIDClock systemTimeClock()
```

Since:
    4.3

#### `currentTimeMillis()`
```java
public long currentTimeMillis()
```
Returns the current time in milliseconds.

### Inherited Methods from Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
```

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

### EthernetAddress Constructors

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Constructors for creating an EthernetAddress instance from different data formats.

```java
public EthernetAddress(String addrStr)
                throws NumberFormatException
```

```java
public EthernetAddress(byte[] addr)
                throws NumberFormatException
```

```java
public EthernetAddress(long addr)
```

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

### EthernetAddress toByteArray Overloads

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Overloaded methods for populating a provided byte array with the MAC address. The toByteArray(byte[] array, int pos) method allows specifying the starting position in the array.

```java
public void toByteArray(byte[] array)
```

```java
public void toByteArray(byte[] array,            int pos)
```

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

### Get Timestamp for UUID Generation

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Constructs a unique timestamp suitable for use in generating time-based UUIDs. This method is the main synchronization point and handles internal logic to ensure monotonically increasing timestamps.

```java
long getTimestamp()
```

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

### UUIDTimer Constructor (Random, TimestampSynchronizer, UUIDClock)

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Initializes UUIDTimer with random number generator, timestamp synchronizer, and a clock provider. Requires IOException if sync initialization fails. Available since version 3.3.

```java
public
UUIDTimer(Random
rnd,
TimestampSynchronizer
sync,
UUIDClock
clock)
throws IOException
```

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

### Method Definitions

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedEpochRandomGenerator.html

Core methods for generating UUIDs and accessing generator metadata.

```java
public UUIDType getType()
```

```java
public UUID generate()
```

```java
public UUID construct(long rawTimestamp)
```

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

### UUIDUtil Utility Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

Documentation for static utility methods provided by the UUIDUtil class for UUID operations.

```APIDOC
## nilUUID

### Description
Accessor for the "Nil UUID" (all zeroes) as defined in RFC 9562, #5.9.

### Response
- **UUID** - The Nil UUID instance.

## maxUUID

### Description
Accessor for the "Max UUID" (all one bits) as defined in RFC 9562, #5.10.

### Response
- **UUID** - The Max UUID instance.

## uuid(String id)

### Description
Factory method for creating UUIDs from the canonical 36-character string representation.

### Parameters
#### Path Parameters
- **id** (String) - Required - The canonical string representation of the UUID.

## uuid(byte[] bytes)

### Description
Factory method for constructing a UUID instance from a 16-byte array. Note: No validation is performed on the input bytes.

### Parameters
#### Path Parameters
- **bytes** (byte[]) - Required - The 16-byte array representing the UUID.
```

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

### POST /construct

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedEpochGenerator.html

Constructs a UUID instance based on a provided unix epoch timestamp.

```APIDOC
## POST /construct

### Description
Method that will construct an actual UUID instance for a given unix epoch timestamp. Calling this method directly produces distinct UUIDs as entropy is generated to avoid collisions.

### Method
POST

### Parameters
#### Request Body
- **rawTimestamp** (long) - Required - Unix epoch millis.

### Response
#### Success Response (200)
- **UUID** (object) - Unix epoch time based UUID.
```

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

### EthernetAddress Helper Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Helper methods for accessing the random number generator and performing default cloning. The _randomNumberGenerator() is protected, suggesting internal use.

```java
protected static Random _randomNumberGenerator()
```

```java
public Object clone()
```

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

### Constructor Definition

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedReorderedGenerator.html

Constructor for initializing the generator with a hardware address and a timer.

```java
public TimeBasedReorderedGenerator(EthernetAddress ethAddr,
                                   UUIDTimer timer)
```

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

### MeasurePerformance Class

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/perf/MeasurePerformance.html

A simple micro-benchmark for evaluating UUID generation performance. It compares JDK's method with JUG's versions. Assumes plain Strings for name-based generation.

```java
public class MeasurePerformance
extends Object
```

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

### RandomBasedGenerator Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/RandomBasedGenerator.html

Details of the constructor for RandomBasedGenerator, including parameter information.

```APIDOC
## Constructor: RandomBasedGenerator

### Signature
```java
public RandomBasedGenerator(Random rnd)
```

### Parameters
- **rnd** (Random) - Random number generator to use for generating UUIDs; if null, shared default generator is used. Note that it is strongly recommend to use a **good** (pseudo) random number generator; for example, JDK's `SecureRandom`.
```

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

### Find egress interface using aggregate finders

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Tries multiple discovery mechanisms in order until one succeeds.

```java
public NetworkInterface fromAggregate(com.fasterxml.uuid.EgressInterfaceFinder.Finder[] finders)
                               throws EgressInterfaceFinder.EgressResolutionException
```

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

### Generators with EthernetAddress Parameters

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/class-use/EthernetAddress.html

Details on how to use EthernetAddress instances when creating time-based UUID generators.

```APIDOC
## Generators with EthernetAddress Parameters

### Description
These factory methods in the Generators class allow for the creation of time-based UUID generators (version 1) using a specified Ethernet address for the location part of the UUID.

### Methods

- **timeBasedGenerator(EthernetAddress ethernetAddress)** (static TimeBasedGenerator) - Factory method for constructing a version 1 UUID generator using the provided Ethernet address.
- **timeBasedGenerator(EthernetAddress ethernetAddress, TimestampSynchronizer sync)** (static TimeBasedGenerator) - Factory method for constructing a version 1 UUID generator using the provided Ethernet address and a TimestampSynchronizer.
- **timeBasedGenerator(EthernetAddress ethernetAddress, UUIDTimer timer)** (static TimeBasedGenerator) - Factory method for constructing a version 1 UUID generator using the provided Ethernet address and a UUIDTimer instance.

### Request Example
```json
{
  "example": "// Assuming 'ethernetAddress' is an instance of EthernetAddress\nTimeBasedGenerator generator = Generators.timeBasedGenerator(ethernetAddress);"
}
```

### Response
#### Success Response (200)
- **TimeBasedGenerator** (TimeBasedGenerator) - An instance of the TimeBasedGenerator.
```

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

### Jug Class Overview

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

The Jug class serves as a simple command-line interface for the UUID generation functionality provided by the library.

```APIDOC
## Class Jug

```java
public class Jug
extends Object
```

Simple command-line interface to UUID generation functionality.

### Fields
- `OPTIONS` (HashMap<String, String>) - Protected static HashMap for options.
- `TYPES` (HashMap<String, String>) - Protected static HashMap for types.

### Constructors
- `Jug()` - Default constructor.

### Methods
- `main(String[] args)` - Public static method to run the UUID generator from the command line.
- `printUsage()` - Protected method to print usage instructions.
- `run(String[] args)` - Public method to execute the UUID generation process with given arguments.
```

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

### Find egress interface using default mechanisms

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Attempts to find the default egress interface by connecting to root DNS nameservers or specific IP addresses.

```java
public NetworkInterface fromDefaultMechanisms(int timeoutMillis)
                                       throws EgressInterfaceFinder.EgressResolutionException
```

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

### Constructor Definitions

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedEpochRandomGenerator.html

Constructors for initializing the generator with a random number source and optional clock.

```java
public TimeBasedEpochRandomGenerator(Random rnd)
```

```java
public TimeBasedEpochRandomGenerator(Random rnd,
                                     UUIDClock clock)
```

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

### EgressInterfaceFinder Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/class-use/EgressInterfaceFinder.EgressResolutionException.html

Methods for finding the default egress network interface on the system.

```APIDOC
## EgressInterfaceFinder.egressInterface()

### Description
Attempt to find the default egress interface on the current system.

### Method
Static Method

### Response
- **NetworkInterface** - The identified network interface.

---

## EgressInterfaceFinder.fromAggregate(Finder[] finders)

### Description
Attempt to find the default egress interface on the current system by trying each of the specified discovery mechanisms in order.

### Parameters
#### Request Body
- **finders** (Finder[]) - Required - Array of discovery mechanisms to attempt.

### Response
- **NetworkInterface** - The identified network interface.

---

## EgressInterfaceFinder.fromDefaultMechanisms(int timeoutMillis)

### Description
Attempt to find the default egress interface on the current system using specified connection timeout duration.

### Parameters
#### Request Body
- **timeoutMillis** (int) - Required - Connection timeout in milliseconds.

### Response
- **NetworkInterface** - The identified network interface.

---

## EgressInterfaceFinder.fromRemoteConnection(int timeoutMillis, InetSocketAddress remoteAddress)

### Description
Attempt to find the default egress interface on the current system by connecting to the specified address.

### Parameters
#### Request Body
- **timeoutMillis** (int) - Required - Connection timeout in milliseconds.
- **remoteAddress** (InetSocketAddress) - Required - The remote address to connect to.
```

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

### MeasurePerformance Class

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Simple micro-benchmark for evaluating UUID generation performance.

```APIDOC
## MeasurePerformance Class

### Description

Simple micro-benchmark for evaluating performance of various UUID generation techniques, including JDK's method as well as JUG's versions.

### Constructors

- `MeasurePerformance()`
- `MeasurePerformance(int iterations, boolean warmUp)`
```

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

### EthernetAddress Class Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/class-use/EthernetAddress.html

This section details the methods related to the EthernetAddress class, including factory methods for constructing addresses and methods for comparing them.

```APIDOC
## EthernetAddress Class Methods

### Description
Provides factory methods to construct EthernetAddress objects from various inputs and methods for comparison.

### Methods

#### Factory Methods

- **constructMulticastAddress()** (static EthernetAddress) - Factory method to construct a random multicast address.
- **constructMulticastAddress(Random rnd)** (static EthernetAddress) - Factory method to construct a random multicast address using a provided Random instance.
- **fromEgressInterface()** (static EthernetAddress) - Factory method to determine the Ethernet address of the network interface connecting to the default gateway.
- **fromInterface()** (static EthernetAddress) - Factory method to locate a network interface with a suitable MAC address and return its Ethernet address.
- **fromInterface(NetworkInterface nint)** (static EthernetAddress) - Factory method to return the Ethernet address of a specified network interface.
- **fromPreferredInterface()** (static EthernetAddress) - Factory method to locate a network interface with a suitable MAC address and return its Ethernet address.
- **valueOf(byte[] addr)** (static EthernetAddress) - Constructs a new EthernetAddress from a byte array representing the binary address.
- **valueOf(int[] addr)** (static EthernetAddress) - Constructs a new EthernetAddress from an integer array representing the address.
- **valueOf(long addr)** (static EthernetAddress) - Constructs a new EthernetAddress from a 64-bit long integer value.
- **valueOf(String addrStr)** (static EthernetAddress) - Constructs a new EthernetAddress from a string representation of the address.

#### Comparison Method

- **compareTo(EthernetAddress other)** (int) - Compares this EthernetAddress to another EthernetAddress.

### Request Example
```json
{
  "example": "No direct request body for these factory methods, typically called directly."
}
```

### Response
#### Success Response (200)
- **EthernetAddress** (EthernetAddress) - An instance of the EthernetAddress class.
```

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

### Ethernet Address Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Methods for inspecting Ethernet address properties.

```APIDOC
## EthernetAddress

### Description
Represents and provides information about an Ethernet address.

### Methods

#### isLocallyAdministeredAddress()
- **Description**: Checks if this address refers to a "locally administered address".
- **Method**: N/A (Method within a class)
- **Endpoint**: N/A

#### isMulticastAddress()
- **Description**: Checks if this address refers to a multicast address.
- **Method**: N/A (Method within a class)
- **Endpoint**: N/A
```

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

### Create Time-Based Generator with Ethernet Address and Synchronizer

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Factory method for constructing a UUID generator using version 1 (time+location based), using a specified Ethernet address and a TimestampSynchronizer. The synchronizer may add restrictions to guarantee system-wide uniqueness.

```java
public static TimeBasedGenerator timeBasedGenerator(EthernetAddress ethernetAddress, TimestampSynchronizer sync)
```

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

### EthernetAddress Factory Methods for Address Construction

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Factory methods to construct multicast addresses or obtain the MAC address of the local network interface. fromEgressInterface() attempts to find the address of the default gateway's interface.

```java
public static EthernetAddress constructMulticastAddress()
```

```java
public static EthernetAddress constructMulticastAddress(Random rnd)
```

```java
public static EthernetAddress fromEgressInterface()
```

```java
public static EthernetAddress fromInterface()
```

```java
public static EthernetAddress fromInterface(NetworkInterface nint)
```

```java
public static EthernetAddress fromPreferredInterface()
```

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

### UUIDTimer Constructor (Random, TimestampSynchronizer)

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Initializes UUIDTimer with a random number generator and a timestamp synchronizer. May throw an IOException if synchronization initialization fails.

```java
public
UUIDTimer(Random
rnd,
TimestampSynchronizer
sync)
throws IOException
```

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

### UUIDTimer Constructors

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Details the constructors available for the UUIDTimer class.

```APIDOC
## UUIDTimer Constructors

### Constructor Summary

- **`UUIDTimer(Random rnd, TimestampSynchronizer sync)`**: Constructor that initializes the UUIDTimer with a random number generator and a timestamp synchronizer.
- **`UUIDTimer(Random rnd, TimestampSynchronizer sync, UUIDClock clock)`**: Constructor that initializes the UUIDTimer with a random number generator, a timestamp synchronizer, and a specific clock implementation.
```

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

### MeasurePerformance Constructor with Parameters

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/perf/MeasurePerformance.html

Constructor for MeasurePerformance that allows specifying the number of rounds and whether to run indefinitely.

```java
public MeasurePerformance(int rounds,
                          boolean runForever)
```

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

### RandomBasedGenerator Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/RandomBasedGenerator.html

Initializes a RandomBasedGenerator with a specified Random instance. If null is provided, a shared default generator is used. Using SecureRandom is recommended.

```java
public RandomBasedGenerator(Random rnd)
```

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

### Method: generate()

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/NoArgGenerator.html

The generate method is an abstract method used to produce a new UUID instance.

```APIDOC
## generate()

### Description
Generates a new UUID instance.

### Returns
- **UUID** - The newly generated UUID object.
```

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

### UUIDUtil Utility Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Utility methods for UUID type identification and factory creation from strings or byte arrays.

```APIDOC
## Method typeOf(UUID)

### Description
Determines the type of the provided UUID.

### Parameters
- **uuid** (UUID) - Required - The UUID to inspect.

## Method uuid(String)

### Description
Factory method for creating a UUID from its canonical string representation.

### Parameters
- **uuidString** (String) - Required - The canonical string representation.
```

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

### Compare EthernetAddresses

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Compares this EthernetAddress to another. Comparison is done by comparing individual address bytes in order.

```java
public int compareTo(EthernetAddress other)
```

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

### Jug Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

The default constructor for the Jug class.

```java
public
Jug()
```

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

### EthernetAddress equals and hashCode

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Standard equals and hashCode methods for comparing EthernetAddress objects. These are essential for using EthernetAddress instances in collections.

```java
public boolean equals(Object o)
```

```java
public int hashCode()
```

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

### EthernetAddress Conversion Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Methods for converting EthernetAddress instances to different formats like byte arrays, long values, or strings.

```APIDOC
## Conversion Methods

### Description
Methods to export the encapsulated MAC address into standard data formats.

### Methods
- `asByteArray()`: Returns the 6-byte binary representation.
- `toLong()`: Returns the address as a long value.
- `toString()`: Returns the canonical string representation (e.g., '00:C0:F0:3D:5B:7C').

### Response
- **byte[] / long / String** - The representation of the MAC address.
```

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

### Log Warning Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/LoggerFacade.html

Methods for logging warning messages with varying numbers of arguments.

```java
public void warn(String msg)
```

```java
public void warn(String msg,
                 Object arg)
```

```java
public void warn(String msg,
                 Object arg,
                 Object arg2)
```

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

### UUIDGenerator Class Overview

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDGenerator.html

Provides an overview of the abstract UUIDGenerator class, its purpose, and known subclasses.

```APIDOC
## Class Overview

`public abstract class UUIDGenerator extends Object`

Minimal "tag" base class from which all generator implementations derive. Actual generation methods are not included since different generators take different number of arguments.

Since: 3.0

Direct Known Subclasses:
NoArgGenerator, StringArgGenerator
```

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

### test Method

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/perf/MeasurePerformance.html

Executes the performance test. This method may throw an Exception.

```java
public void test()
          throws Exception
```

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

### Construct a Time-Based UUID Generator

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Creates a version 1 UUID generator using a specific Ethernet address and UUID timer.

```java
public static TimeBasedGenerator timeBasedGenerator(EthernetAddress ethernetAddress,
                                                    UUIDTimer timer)
```

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

### TimeBasedGenerator Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedGenerator.html

Documentation for the methods available in the TimeBasedGenerator class, including UUID generation and type access.

```APIDOC
## Methods: TimeBasedGenerator

### `generate()`

- **Method:** `public UUID generate()`
- **Description:** Method for generating a `UUID`.
- **Returns:** Newly generated `UUID`.

### `construct(long rawTimestamp)`

- **Method:** `public UUID construct(long rawTimestamp)`
- **Description:** Method that will construct actual `UUID` instance for given timestamp: called by `generate()` but may alternatively be called directly to construct an instance with known timestamp. NOTE: calling this method directly does NOT guarantee uniqueness of resulting `UUID` (caller has to guarantee uniqueness).
- **Parameters:**
  - **rawTimestamp** (long) - Timestamp usually obtained from `UUIDTimer.getTimestamp()`, used for constructing UUID instance.
- **Returns:** unix Time-based UUID constructed for given timestamp.
- **Since:** 4.3

### `getType()`

- **Method:** `public UUIDType getType()`
- **Description:** Accessor for determining type of UUIDs (version) that this generator instance will produce.
- **Inherited From:** `UUIDGenerator`

### `getEthernetAddress()`

- **Method:** `public EthernetAddress getEthernetAddress()`
- **Description:** Returns the Ethernet address used by this generator.
```

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

### EthernetAddress Constructors

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Constructs an EthernetAddress from a byte array, a long, or a standard MAC address string. Ensure the input format is correct for the respective constructor.

```java
public EthernetAddress(byte[] addr)
```

```java
public EthernetAddress(long addr)
```

```java
public EthernetAddress(String addrStr)
```

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

### EthernetAddress Methods for Conversion and Comparison

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Provides methods to convert the MAC address to a byte array or long, and to compare it with other EthernetAddress instances. The asByteArray() and toByteArray() methods are synonyms.

```java
public byte[] asByteArray()
```

```java
public int compareTo(EthernetAddress other)
```

```java
public long toLong()
```

```java
public String toString()
```

```java
public byte[] toByteArray()
```

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

### EthernetAddress Constructors

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Constructors for the EthernetAddress class which encapsulates 6-byte MAC addresses.

```APIDOC
## Constructor: EthernetAddress(String)

### Description
Constructs an EthernetAddress instance from a standard ethernet MAC address string (e.g., '00:C0:F0:3D:5B:7C').

## Constructor: EthernetAddress(byte[])

### Description
Constructs an instance given the 6 byte (48-bit) address.

## Constructor: EthernetAddress(long)

### Description
Constructs an instance from the given long argument; the lowest 6 bytes contain the address.
```

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

### UUIDTimer Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Details the methods of the UUIDTimer class.

```APIDOC
## UUIDTimer Methods

### Method Summary

#### Instance Methods

- **`getAndSetTimestamp(byte[] uuidBytes)`**: (protected) Sets the timestamp information into the provided byte array for a UUID.
- **`getClockSequence()`**: (int) Retrieves the current clock sequence value.
- **`getTimestamp()`**: (long) Constructs a unique timestamp suitable for use for constructing UUIDs. This is the main synchronization point.
- **`slowDown(long startTime, long actDiff)`**: (protected) A utility method to wait for a few milliseconds, allowing the system clock to advance if it's lagging behind the generated timestamps.

#### Static Methods

- **`timestampToEpoch(long timestamp)`**: (static, long) Converts a UUID v1 or v6 timestamp (in 100-nanosecond units) to a Unix epoch timestamp (in milliseconds since 01-Jan-1970 UTC).
```

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

### TimeBasedGenerator Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedGenerator.html

Details the constructor for the TimeBasedGenerator class, used to initialize a new instance with an Ethernet address and a UUID timer.

```APIDOC
## Constructor: TimeBasedGenerator

### Signature
`public TimeBasedGenerator(EthernetAddress ethAddr, UUIDTimer timer)`

### Parameters
- **ethAddr** (EthernetAddress) - Hardware address (802.1) to use for generating spatially unique part of UUID. If system has more than one NIC,
- **timer** (UUIDTimer) - Object used for synchronizing access to timestamps, to guarantee that timestamps produced by this generator are unique and monotonically increasings.
```

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

### Construct EgressResolutionException instances

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.EgressResolutionException.html

Constructors for creating instances of EgressResolutionException with messages, causes, or prior exceptions.

```java
public
EgressResolutionException(String
message)
```

```java
public
EgressResolutionException(String
message,
                                 Throwable
cause)
```

```java
public
EgressResolutionException(EgressInterfaceFinder.EgressResolutionException[]
priors)
```

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

### Convert EthernetAddress to Byte Array (Synonym)

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Synonym for asByteArray(). Returns a 6-byte array representing the binary form of the ethernet address.

```java
public byte[] toByteArray()
```

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

### UUID Construction Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Methods for constructing UUID instances based on timestamps or specific byte arrays.

```APIDOC
## UUID Construction

### construct(long timestamp)
- **Description**: Constructs a UUID instance for a given timestamp.
- **Parameters**:
  - **timestamp** (long) - Required - The timestamp to use for UUID construction.

### constructUUID(UUIDType type, byte[] data)
- **Description**: Helper method for constructing UUID instances with an appropriate type.
- **Parameters**:
  - **type** (UUIDType) - Required - The type of UUID.
  - **data** (byte[]) - Required - The binary data for the UUID.
```

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

### EgressInterfaceFinder.egressInterface()

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Utility method to attempt to find the default egress network interface on the current system.

```APIDOC
## Method: egressInterface()

### Description
Attempt to find the default egress interface on the current system.

### Class
com.fasterxml.uuid.EgressInterfaceFinder
```

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

### Create Time-Based Epoch Generator with Random

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Factory method for constructing a UUID generator using version 7 (Unix Epoch time+random based). Uses a specified Random number generator. Calls within the same millisecond produce very similar values, which may be unsafe in some environments. No additional external synchronization is used.

```java
public static TimeBasedEpochGenerator timeBasedEpochGenerator(Random random)
```

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

### TimeBasedGenerator Class Overview

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/TimeBasedGenerator.html

Provides an overview of the TimeBasedGenerator class, its inheritance, and its purpose in generating time-based UUIDs.

```APIDOC
## Class: TimeBasedGenerator

### Description
Implementation of UUID generator that uses time/location based generation method (version 1). As all JUG provided implementations, this generator is fully thread-safe. Additionally, it can also be made externally synchronized with other instances (even ones running on other JVMs); to do this, use `FileBasedTimestampSynchronizer` (or equivalent).

Since: 3.0

### Inheritance
- `java.lang.Object`
  - `com.fasterxml.uuid.UUIDGenerator`
    - `com.fasterxml.uuid.NoArgGenerator`
      - `com.fasterxml.uuid.impl.TimeBasedGenerator`
```

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

### com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer Constants

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/constant-values.html

This section details the constants available in the FileBasedTimestampSynchronizer class.

```APIDOC
## com.fasterxml.uuid.ext.FileBasedTimestampSynchronizer Constants

### Description
Constants related to file-based timestamp synchronization.

### Constants
- **DEFAULT_LOCK_FILE_NAME1** (String) - The first default lock file name.
- **DEFAULT_LOCK_FILE_NAME2** (String) - The second default lock file name.
```

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

### NameBasedGenerator Constructor

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/NameBasedGenerator.html

Constructor for initializing the generator with a namespace, digester, and UUID type.

```java
public NameBasedGenerator(UUID namespace,
                          MessageDigest digester,
                          UUIDType type)
```

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

### NameBasedGenerator Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/NameBasedGenerator.html

Methods for generating name-based UUIDs and accessing generator configuration.

```APIDOC
## generate(String name)

### Description
Generates a name-based UUID using the specified name, which is serialized to bytes using UTF-8 encoding.

### Parameters
#### Request Body
- **name** (String) - Required - The name string to be used for UUID generation.

### Response
#### Success Response (200)
- **UUID** (Object) - The generated UUID object.

## generate(byte[] nameBytes)

### Description
Generates a name-based UUID using the specified byte-serialization of the name.

### Parameters
#### Request Body
- **nameBytes** (byte[]) - Required - The byte array representing the name.

### Response
#### Success Response (200)
- **UUID** (Object) - The generated UUID object.

## getType()

### Description
Accessor for determining the type (version) of UUIDs that this generator instance will produce.

### Response
#### Success Response (200)
- **UUIDType** (Object) - The version type of the generator.
```

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

### NameBasedGenerator Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/NameBasedGenerator.html

Methods for retrieving generator configuration and producing UUIDs from strings or byte arrays.

```java
public UUIDType getType()
```

```java
public UUID getNamespace()
```

```java
public UUID generate(String name)
```

```java
public UUID generate(byte[] nameBytes)
```

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

### Report and retrieve diagnostic information

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.EgressResolutionException.html

Methods for reporting egress resolution failures and retrieving collected diagnostic messages.

```java
public
void
report()
```

```java
protected
void
reportLine(String
line)
```

```java
public
Collection<String>
getMessages()
```

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

### Convert byte buffer to short

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDGenerator.html

Utility method to convert a byte array to a short value.

```java
protected static final long _toShort(byte[] buffer,
                                     int offset)
```

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

### TimestampSynchronizer initialize Method

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/TimestampSynchronizer.html

Abstract method called by UUIDTimer upon configuration. Implementations should determine the first legal timestamp and initialize any necessary locking mechanisms. Returns 0L if the initial value cannot be determined.

```java
protected abstract long initialize() throws IOException
```

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

### Construct Random Multicast EthernetAddress with Random Generator

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Factory method to construct a random multicast address using a specified random number generator. Ensures the generated address is a multicast address to avoid collisions with real MAC addresses.

```java
public static EthernetAddress constructMulticastAddress(Random rnd)
```

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

### Create Time-Based Random Epoch Generator with Random

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Factory method for constructing a UUID generator using version 7 (Unix Epoch time+random based). Uses a specified Random number generator. Calls within the same millisecond use additional per-call randomness to create more distinct values compared to timeBasedEpochGenerator(Random). No additional external synchronization is used.

```java
public static TimeBasedEpochRandomGenerator timeBasedEpochRandomGenerator(Random random)
```

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

### EgressInterfaceFinder Methods

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/index-all.html

Methods for identifying the default egress network interface using various discovery mechanisms.

```APIDOC
## EgressInterfaceFinder Discovery Methods

### Description
Provides utilities to find the default egress network interface on the current system using different strategies.

### Methods
- **fromAggregate(Finder[])**: Tries multiple discovery mechanisms in order.
- **fromDefaultMechanisms(int)**: Uses default mechanisms with a specified connection timeout.
- **fromLocalAddress(InetAddress)**: Finds an interface associated with a specific local address.
- **fromRemoteConnection(int, InetSocketAddress)**: Connects to a remote address to identify the egress interface.
- **fromRemoteDatagramSocketConnection(InetSocketAddress)**: Uses a DatagramSocket connection.
- **fromRemoteSocketConnection(int, InetSocketAddress)**: Uses a Socket connection.
- **fromRootNameserverConnection(int)**: Connects to a random root nameserver to identify the interface.
```

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

### Initialize UUIDGenerator

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDGenerator.html

Protected constructor for the UUIDGenerator class.

```java
protected UUIDGenerator()
```

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

### EgressInterfaceFinder.fromAggregate

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Attempts to find the default egress interface by trying a provided array of discovery mechanisms in order.

```APIDOC
## POST /api/egress/aggregate

### Description
Attempts to find the default egress interface on the current system, by trying each of the specified discovery mechanisms, in order, until one of them succeeds.

### Method
POST

### Endpoint
/api/egress/aggregate

### Parameters
#### Request Body
- **finders** (Array<Finder>) - Required - Array of finder callbacks to be executed

### Request Example
```json
{
  "finders": [
    {
      "type": "com.fasterxml.uuid.EgressInterfaceFinder.Finder"
    }
  ]
}
```

### Response
#### Success Response (200)
- **networkInterface** (NetworkInterface) - The egress interface

#### Response Example
```json
{
  "networkInterface": "eth0"
}
```

### Throws
- **EgressInterfaceFinder.EgressResolutionException** - if an egress interface could not be determined
```

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

### Construct Random Multicast EthernetAddress

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EthernetAddress.html

Factory method to construct a random multicast address. This is useful when a real ethernet address is not available, ensuring the generated address avoids collision with real MAC addresses.

```java
public static EthernetAddress constructMulticastAddress()
```

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

### Jug Class - Field Details

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Jug.html

Detailed information about the fields within the Jug class.

```APIDOC
## Field Details

### TYPES
```java
protected static final HashMap<String,String> TYPES
```

### OPTIONS
```java
protected static final HashMap<String,String> OPTIONS
```
```

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

### UUIDTimer Class Overview

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/UUIDTimer.html

Provides an overview of the UUIDTimer class and its purpose in generating timestamps for UUIDs.

```APIDOC
## UUIDTimer Class

### Description
Produces the timestamps required for time-based UUIDs. It compensates for low clock resolution using a counter and handles potential clock changes.

### Implementation Details
- Compensates for millisecond clock resolution with a counter (up to 10000 UUIDs per clock update).
- Handles lower clock resolutions on some platforms by advancing the timestamp value within limits.
- Initializes the counter with a random 8-bit number to reduce multi-JVM collision likelihood.
- Supports optional external timestamp synchronization using file-based locking (since version 2.0).
- Assumes `System.currentTimeMillis()` provides UTC time offset.
- Assumes the time offset between 1.1.1970 and the Gregorian calendar start is correct.
- Synchronization is primarily handled by `getTimestamp()`, reducing the need for explicit caller synchronization.
```

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

### Construct UUID with Type and Bytes

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/impl/UUIDUtil.html

A helper method for constructing UUID instances with a specified type and byte array.

```java
public static UUID constructUUID(UUIDType type,
              byte[] uuidBytes)
```

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

### POST /generators/timeBased

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/Generators.html

Constructs a UUID generator using version 1 (time+location based).

```APIDOC
## POST /generators/timeBased

### Description
Factory method for constructing a UUID generator that generates UUIDs using version 1 (time+location based).

### Method
POST

### Parameters
#### Request Body
- **ethernetAddress** (EthernetAddress) - Required - The hardware address of the egress network interface.
- **sync** (TimestampSynchronizer) - Optional - Synchronizer to guarantee system-wide uniqueness.
- **timer** (UUIDTimer) - Optional - Instance that includes embedded synchronizer defining synchronization behavior.
```

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

### Find egress interface via root nameserver

Source: https://www.javadoc.io/doc/com.fasterxml.uuid/java-uuid-generator/5.2.0/com/fasterxml/uuid/EgressInterfaceFinder.html

Attempts to determine the egress interface by connecting to a randomly chosen root name server.

```java
public NetworkInterface fromRootNameserverConnection(int timeoutMillis)
                                              throws EgressInterfaceFinder.EgressResolutionException
```
Tokens:
Raw