add uuid v6, v7

util.go

@@ -41,3 +41,21 @@ func xtob(x1, x2 byte) (byte, bool) {
 	b2 := xvalues[x2]
 	return (b1 << 4) | b2, b1 != 255 && b2 != 255
 }
+
+// fill uuid (16byte) from poll
+func fill16BytesFromPool(b []byte) error {
+	poolMu.Lock()
+	if poolPos == randPoolSize {
+		_, err := io.ReadFull(rander, pool[:])
+		if err != nil {
+			poolMu.Unlock()
+			return err
+		}
+		poolPos = 0
+	}
+	copy(b, pool[poolPos:(poolPos+16)])
+	poolPos += 16
+	poolMu.Unlock()
+
+	return nil
+}

uuid_test.go

@@ -73,6 +73,9 @@ var tests = []test{
 	{"f47ac10b58cc037285670e02b2c3d479", 0, RFC4122, true},
 	{"f47ac10b58cc037285670e02b2c3d4790", 0, Invalid, false},
 	{"f47ac10b58cc037285670e02b2c3d47", 0, Invalid, false},
+
+	{"01ee82e2-0b7f-68ce-b3a5-525400475911", 6, RFC4122, true},
+	{"018bcd9e-4f69-712e-9eb1-dcec29d8ebc3", 7, RFC4122, true},
 }
 
 var constants = []struct {

version4.go

@@ -9,15 +9,15 @@ import "io"
 // New creates a new random UUID or panics.  New is equivalent to
 // the expression
 //
-//    uuid.Must(uuid.NewRandom())
+// uuid.Must(uuid.NewRandom())
 func New() UUID {
 	return Must(NewRandom())
 }
 
 // NewString creates a new random UUID and returns it as a string or panics.
 // NewString is equivalent to the expression
 //
-//    uuid.New().String()
+// uuid.New().String()
 func NewString() string {
 	return Must(NewRandom()).String()
 }
@@ -31,11 +31,11 @@ func NewString() string {
 //
 // A note about uniqueness derived from the UUID Wikipedia entry:
 //
-//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
-//  hit by a meteorite is estimated to be one chance in 17 billion, that
-//  means the probability is about 0.00000000006 (6 × 10−11),
-//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
-//  year and having one duplicate.
+//	Randomly generated UUIDs have 122 random bits.  One's annual risk of being
+//	hit by a meteorite is estimated to be one chance in 17 billion, that
+//	means the probability is about 0.00000000006 (6 × 10−11),
+//	equivalent to the odds of creating a few tens of trillions of UUIDs in a
+//	year and having one duplicate.
 func NewRandom() (UUID, error) {
 	if !poolEnabled {
 		return NewRandomFromReader(rander)
@@ -57,18 +57,9 @@ func NewRandomFromReader(r io.Reader) (UUID, error) {
 
 func newRandomFromPool() (UUID, error) {
 	var uuid UUID
-	poolMu.Lock()
-	if poolPos == randPoolSize {
-		_, err := io.ReadFull(rander, pool[:])
-		if err != nil {
-			poolMu.Unlock()
-			return Nil, err
-		}
-		poolPos = 0
+	if err := fill16BytesFromPool(uuid[:]); err != nil {
+		return Nil, err
 	}
-	copy(uuid[:], pool[poolPos:(poolPos+16)])
-	poolPos += 16
-	poolMu.Unlock()
 
 	uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
 	uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10

version6.go

@@ -0,0 +1,36 @@
+// Copyright 2018 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "encoding/binary"
+
+// NewV6 returns a Version 6 UUID based on the current NodeID and clock
+// sequence, and the current time.  If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
+// be set NewV6 returns nil.  If clock sequence has not been set by
+// SetClockSequence then it will be set automatically.  If GetTime fails to
+// return the current NewV6 returns nil and an error.
+func NewV6() (UUID, error) {
+	var uuid UUID
+	now, seq, err := GetTime()
+	if err != nil {
+		return uuid, err
+	}
+
+	binary.BigEndian.PutUint64(uuid[0:], uint64(now))
+	binary.BigEndian.PutUint16(uuid[8:], seq)
+
+	uuid[6] = 0x60 | (uuid[6] & 0x0F)
+	uuid[8] = 0x80 | (uuid[8] & 0x3F)
+
+	nodeMu.Lock()
+	if nodeID == zeroID {
+		setNodeInterface("")
+	}
+	copy(uuid[10:], nodeID[:])
+	nodeMu.Unlock()
+
+	return uuid, nil
+}

version7.go

@@ -0,0 +1,70 @@
+// Copyright 2018 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+func unixepoch() (uint64, error) {
+	now, _, err := GetTime()
+	if err != nil {
+		return 0, err
+	}
+
+	sec, nsec := now.UnixTime()
+	return uint64(sec*1000 + nsec/1000000), nil
+}
+
+func NewV7FromReader(r io.Reader) (UUID, error) {
+	var uuid UUID
+
+	t, err := unixepoch()
+	if err != nil {
+		return uuid, err
+	}
+
+	binary.BigEndian.PutUint64(uuid[0:], t<<16)
+	_, err = io.ReadFull(r, uuid[6:])
+	if err != nil {
+		return Nil, err
+	}
+
+	uuid[6] = 0x70 | (uuid[6] & 0x0F)
+	uuid[8] = 0x80 | (uuid[8] & 0x3F)
+
+	return uuid, nil
+}
+
+func newV7FromPool() (UUID, error) {
+	var uuid UUID
+
+	t, err := unixepoch()
+	if err != nil {
+		return uuid, err
+	}
+
+	if err = fill16BytesFromPool(uuid[:]); err != nil {
+		return Nil, err
+	}
+
+	binary.BigEndian.PutUint32(uuid[0:], uint32(t>>16))
+	binary.BigEndian.PutUint16(uuid[4:], uint16(t))
+
+	uuid[6] = 0x70 | (uuid[6] & 0x0F)
+	uuid[8] = 0x80 | (uuid[8] & 0x3F)
+
+	return uuid, nil
+}
+
+// NewV7 returns a Version 7 UUID based on the current time.
+// If GetTime fails to  return the current NewV7 returns nil and an error.
+func NewV7() (UUID, error) {
+	if !poolEnabled {
+		return NewV7FromReader(rander)
+	}
+	return newV7FromPool()
+}