133 lines
4.7 KiB
Nim
133 lines
4.7 KiB
Nim
import strutils, hashes
|
|
import isaac
|
|
import uuids/urandom
|
|
|
|
type
|
|
UUID* = object
|
|
## 128-bit UUID compliant with RFC-4122
|
|
mostSigBits: int64
|
|
leastSigBits: int64
|
|
|
|
template toHex(s: string, start: Natural,
|
|
x: BiggestInt, len: Positive) =
|
|
const HexChars = ['0', '1', '2', '3', '4', '5', '6', '7', '8',
|
|
'9', 'a', 'b', 'c', 'd', 'e', 'f']
|
|
var n = x
|
|
for j in countdown(len - 1, 0):
|
|
s[start + j] = HexChars[int(n and 0xF)]
|
|
n = n shr 4
|
|
# handle negative overflow
|
|
if n == 0 and x < 0: n = -1
|
|
|
|
proc uuidsParseHexInt(s: string, maxLen: int): int64 =
|
|
if s.len == 0:
|
|
raise newException(ValueError, "UUID part is empty")
|
|
if s.len > maxLen or s.len > sizeof(result) * 2:
|
|
raise newException(ValueError, "UUID part is longer than expected")
|
|
for c in s:
|
|
case c
|
|
of '0'..'9':
|
|
result = result shl 4 or (ord(c) - ord('0'))
|
|
of 'a'..'f':
|
|
result = result shl 4 or (ord(c) - ord('a') + 10)
|
|
of 'A'..'F':
|
|
result = result shl 4 or (ord(c) - ord('A') + 10)
|
|
else: raise newException(ValueError, "Invalid hex string: " & s)
|
|
|
|
proc initUUID*(mostSigBits, leastSigBits: int64): UUID =
|
|
## Initializes UUID with the specified most and least significant bits
|
|
result.mostSigBits = mostSigBits
|
|
result.leastSigBits = leastSigBits
|
|
|
|
proc leastSigBits*(uuid: UUID): int64 {.inline.} =
|
|
## Returns 64 least significant bits of the ``uuid``
|
|
uuid.leastSigBits
|
|
|
|
proc mostSigBits*(uuid: UUID): int64 {.inline.} =
|
|
## Returns 64 most significant bits of the ``uuid``
|
|
uuid.mostSigBits
|
|
|
|
proc `$`*(uuid: UUID): string =
|
|
## Returns a string representation of the ``uuid`` in canonical form.
|
|
result = newString(36)
|
|
toHex(result, 0, uuid.mostSigBits shr 32, 8)
|
|
result[8] = '-'
|
|
toHex(result, 9, uuid.mostSigBits shr 16, 4)
|
|
result[13] = '-'
|
|
toHex(result, 14, uuid.mostSigBits, 4)
|
|
result[18] = '-'
|
|
toHex(result, 19, uuid.leastSigBits shr 48, 4)
|
|
result[23] = '-'
|
|
toHex(result, 24, uuid.leastSigBits, 12)
|
|
|
|
proc hash*(uuid: UUID): Hash =
|
|
## Computes hash of the specified ``uuid``.
|
|
result = uuid.mostSigBits.hash() !& uuid.leastSigBits.hash()
|
|
result = !$result
|
|
|
|
proc `==`*(x, y: UUID): bool =
|
|
## Returns ``true`` when the specified UUIDs are equal, ``false`` otherwise.
|
|
x.mostSigBits == y.mostSigBits and x.leastSigBits == y.leastSigBits
|
|
|
|
proc isZero*(uuid: UUID): bool =
|
|
## Returns ``true`` when the ``uuid`` is zero (not set), ``false`` otherwise.
|
|
uuid.mostSigBits == 0'i64 and uuid.leastSigBits == 0'i64
|
|
|
|
var rand {.threadvar.}: IsaacGenerator
|
|
proc genUUID*(): UUID =
|
|
## Returns a random (v4) UUID.
|
|
## Uses a thread-local cryptographically secure PRNG (ISAAC) seeded with
|
|
## true random values obtained from OS.
|
|
if rand == nil:
|
|
var seed = cast[array[256, uint32]](urandom(1024))
|
|
rand = newIsaacGenerator(seed)
|
|
result.mostSigBits = cast[int64]((rand.nextU32().uint64 shl 32) or rand.nextU32())
|
|
result.leastSigBits = cast[int64]((rand.nextU32().uint64 shl 32) or rand.nextU32())
|
|
|
|
# set version to 4
|
|
result.mostSigBits = (result.mostSigBits and 0xFFFFFFFFFFFF0FFF'i64) or
|
|
0x0000000000004000'i64
|
|
# set IETF variant
|
|
result.leastSigBits = (result.leastSigBits and 0x3FFFFFFFFFFFFFFF'i64) or
|
|
0x8000000000000000'i64
|
|
|
|
proc parseUUID*(s: string): UUID {.raises: [ValueError].} =
|
|
## Converts string representation of an UUID to UUID object.
|
|
## Raises ``ValueError`` if invalid format is provided.
|
|
let parts = s.split('-')
|
|
if parts.len != 5:
|
|
raise newException(ValueError,
|
|
"UUID must consist of 5 parts separated with `-`")
|
|
var mostSigBits: int64 = uuidsParseHexInt(parts[0], 8)
|
|
mostSigBits = mostSigBits shl 16
|
|
mostSigBits = mostSigBits or uuidsParseHexInt(parts[1], 4)
|
|
mostSigBits = mostSigBits shl 16
|
|
mostSigBits = mostSigBits or uuidsParseHexInt(parts[2], 4)
|
|
|
|
var leastSigBits: int64 = uuidsParseHexInt(parts[3], 4)
|
|
leastSigBits = leastSigBits shl 48
|
|
leastSigBits = leastSigBits or uuidsParseHexInt(parts[4], 12)
|
|
|
|
result = UUID(mostSigBits: mostSigBits, leastSigBits: leastSigBits)
|
|
|
|
when isMainModule:
|
|
var uuid: UUID
|
|
assert(uuid.isZero())
|
|
for i in 1..100:
|
|
uuid = genUUID()
|
|
let uuidStr = $uuid
|
|
assert(uuidStr.len == 36)
|
|
assert(uuidStr[14] == '4') # version
|
|
assert(uuidStr[19] in {'8', '9', 'a', 'b'}) # variant (2 bits)
|
|
|
|
let parsedUUID = uuidStr.parseUUID()
|
|
assert(parsedUUID == uuid)
|
|
assert(parsedUUID.hash() == uuid.hash())
|
|
assert(mostSigBits(parsedUUID) == mostSigBits(uuid))
|
|
assert(leastSigBits(parsedUUID) == leastSigBits(uuid))
|
|
|
|
let newUUID = initUUID(mostSigBits(uuid), leastSigBits(uuid))
|
|
assert(newUUID == uuid)
|
|
assert(newUUID.hash() == uuid.hash())
|
|
assert(mostSigBits(newUUID) == mostSigBits(uuid))
|
|
assert(leastSigBits(newUUID) == leastSigBits(uuid))
|