diff --git a/vendor/github.com/wayn3h0/go-uuid/LICENSE b/vendor/github.com/wayn3h0/go-uuid/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..fad0aa6350da088c679b81e73dee76ef873491da
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2015 Wayne Ho.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/github.com/wayn3h0/go-uuid/domain.go b/vendor/github.com/wayn3h0/go-uuid/domain.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce09399bcae3b33d13fd12648d20594b9952530a
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/domain.go
@@ -0,0 +1,14 @@
+package uuid
+
+import (
+ "github.com/wayn3h0/go-uuid/internal/dcesecurity"
+)
+
+// Domain represents the identifier for a local domain
+type Domain byte
+
+// Domains.
+const (
+ DomainUser = Domain(dcesecurity.User) // POSIX UID domain
+ DomainGroup = Domain(dcesecurity.Group) // POSIX GID domain
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/dcesecurity.go b/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/dcesecurity.go
new file mode 100644
index 0000000000000000000000000000000000000000..9de07243d9483e479daa7cf6be52b36496d90cf7
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/dcesecurity.go
@@ -0,0 +1,37 @@
+package dcesecurity
+
+import (
+ "encoding/binary"
+ "errors"
+ "os"
+
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/timebased"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+// Generate returns a new DCE security uuid.
+func New(domain Domain) ([]byte, error) {
+ uuid, err := timebased.New()
+ if err != nil {
+ return nil, err
+ }
+
+ switch domain {
+ case User:
+ uid := os.Getuid()
+ binary.BigEndian.PutUint32(uuid[0:], uint32(uid)) // network byte order
+ case Group:
+ gid := os.Getgid()
+ binary.BigEndian.PutUint32(uuid[0:], uint32(gid)) // network byte order
+ default:
+ return nil, errors.New("uuid: domain is invalid")
+ }
+
+ // set version(v2)
+ version.Set(uuid, version.DCESecurity)
+ // set layout(RFC4122)
+ layout.Set(uuid, layout.RFC4122)
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/domain.go b/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/domain.go
new file mode 100644
index 0000000000000000000000000000000000000000..38eae8301fdb4a49fe10e50b74ef64a666919a51
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/dcesecurity/domain.go
@@ -0,0 +1,9 @@
+package dcesecurity
+
+// Domain represents the identifier for a local domain
+type Domain byte
+
+const (
+ User Domain = iota + 1 // POSIX UID domain
+ Group // POSIX GID domain
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/layout/layout.go b/vendor/github.com/wayn3h0/go-uuid/internal/layout/layout.go
new file mode 100644
index 0000000000000000000000000000000000000000..65a84cc463e4e429bbcea37024c1cffc56859daa
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/layout/layout.go
@@ -0,0 +1,12 @@
+package layout
+
+// Layout represents the layout of UUID. See page 5 in RFC 4122.
+type Layout byte
+
+const (
+ Invalid Layout = iota // Invalid
+ NCS // Reserved, NCS backward compatibility. (Values: 0x00-0x07)
+ RFC4122 // The variant specified in RFC 4122. (Values: 0x08-0x0b)
+ Microsoft // Reserved, Microsoft Corporation backward compatibility. (Values: 0x0c-0x0d)
+ Future // Reserved for future definition. (Values: 0x0e-0x0f)
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/layout/utility.go b/vendor/github.com/wayn3h0/go-uuid/internal/layout/utility.go
new file mode 100644
index 0000000000000000000000000000000000000000..7c5fde7beb4acd4386126cbbe93e5cf8040e8b67
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/layout/utility.go
@@ -0,0 +1,33 @@
+package layout
+
+// Set sets the layout for uuid.
+func Set(uuid []byte, layout Layout) {
+ switch layout {
+ case NCS:
+ uuid[8] = (uuid[8] | 0x00) & 0x0f // Msb0=0
+ case RFC4122:
+ uuid[8] = (uuid[8] | 0x80) & 0x8f // Msb0=1, Msb1=0
+ case Microsoft:
+ uuid[8] = (uuid[8] | 0xc0) & 0xcf // Msb0=1, Msb1=1, Msb2=0
+ case Future:
+ uuid[8] = (uuid[8] | 0xe0) & 0xef // Msb0=1, Msb1=1, Msb2=1
+ default:
+ panic("uuid: layout is invalid")
+ }
+}
+
+// Get returns layout of uuid.
+func Get(uuid []byte) Layout {
+ switch {
+ case (uuid[8] & 0x80) == 0x00:
+ return NCS
+ case (uuid[8] & 0xc0) == 0x80:
+ return RFC4122
+ case (uuid[8] & 0xe0) == 0xc0:
+ return Microsoft
+ case (uuid[8] & 0xe0) == 0xe0:
+ return Future
+ }
+
+ return Invalid
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/namebased/md5/md5.go b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/md5/md5.go
new file mode 100644
index 0000000000000000000000000000000000000000..a03e6c71d68cd9f10cbe6591af938122ed803e71
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/md5/md5.go
@@ -0,0 +1,33 @@
+package md5
+
+import (
+ "crypto/md5"
+
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+// New returns a new name-based uses SHA-1 hashing uuid.
+func New(namespace, name string) ([]byte, error) {
+ hash := md5.New()
+ _, err := hash.Write([]byte(namespace))
+ if err != nil {
+ return nil, err
+ }
+ _, err = hash.Write([]byte(name))
+ if err != nil {
+ return nil, err
+ }
+
+ sum := hash.Sum(nil)
+
+ uuid := make([]byte, 16)
+ copy(uuid, sum)
+
+ // set version(v3)
+ version.Set(uuid, version.NameBasedMD5)
+ // set layout(RFC4122)
+ layout.Set(uuid, layout.RFC4122)
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/namebased/namebased.go b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/namebased.go
new file mode 100644
index 0000000000000000000000000000000000000000..f4202676ad56349cf0dee76ef3adae53805f2b66
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/namebased.go
@@ -0,0 +1,9 @@
+package namebased
+
+// Standard Namespaces
+const (
+ NamespaceDNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceURL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceOID = "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceX500 = "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/namebased/sha1/sha1.go b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/sha1/sha1.go
new file mode 100644
index 0000000000000000000000000000000000000000..14a8eeb01c607720d0b2acfb230f3dc431e2d629
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/namebased/sha1/sha1.go
@@ -0,0 +1,33 @@
+package sha1
+
+import (
+ "crypto/sha1"
+
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+// New returns a new name-based uses SHA-1 hashing uuid.
+func New(namespace, name string) ([]byte, error) {
+ hash := sha1.New()
+ _, err := hash.Write([]byte(namespace))
+ if err != nil {
+ return nil, err
+ }
+ _, err = hash.Write([]byte(name))
+ if err != nil {
+ return nil, err
+ }
+
+ sum := hash.Sum(nil)
+
+ uuid := make([]byte, 16)
+ copy(uuid, sum)
+
+ // set version(v5)
+ version.Set(uuid, version.NameBasedSHA1)
+ // set layout(RFC4122)
+ layout.Set(uuid, layout.RFC4122)
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/random/random.go b/vendor/github.com/wayn3h0/go-uuid/internal/random/random.go
new file mode 100644
index 0000000000000000000000000000000000000000..59354280800f18125241c15b9e941198ff2cc0e8
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/random/random.go
@@ -0,0 +1,27 @@
+package random
+
+import (
+ "crypto/rand"
+
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+// New returns a new randomly uuid.
+func New() ([]byte, error) {
+ uuid := make([]byte, 16)
+ n, err := rand.Read(uuid[:])
+ if err != nil {
+ return nil, err
+ }
+ if n != len(uuid) {
+ return nil, err
+ }
+
+ // set version(v4)
+ version.Set(uuid, version.Random)
+ // set layout(RFC4122)
+ layout.Set(uuid, layout.RFC4122)
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/timebased/timebased.go b/vendor/github.com/wayn3h0/go-uuid/internal/timebased/timebased.go
new file mode 100644
index 0000000000000000000000000000000000000000..43541567cf1eaf24fdc4df388608f316e51da635
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/timebased/timebased.go
@@ -0,0 +1,92 @@
+package timebased
+
+import (
+ "crypto/rand"
+ "encoding/binary"
+ "net"
+ "sync"
+ "time"
+
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+const (
+ // Intervals bewteen 1/1/1970 and 15/10/1582 (Julain days of 1 Jan 1970 - Julain days of 15 Oct 1582) * 100-Nanoseconds Per Day
+ intervals = (2440587 - 2299160) * 86400 * 10000000
+)
+
+var (
+ lastGenerated time.Time // last generated time
+ clockSequence uint16 // clock sequence for same tick
+ nodeID []byte // node id (MAC Address)
+ locker sync.Mutex // global lock
+)
+
+// New returns a new time-based uuid.
+func New() ([]byte, error) {
+ // Get and release a global lock
+ locker.Lock()
+ defer locker.Unlock()
+
+ uuid := make([]byte, 16)
+
+ // get timestamp
+ now := time.Now().UTC()
+ timestamp := uint64(now.UnixNano()/100) + intervals // get timestamp
+ if !now.After(lastGenerated) {
+ clockSequence++ // last generated time known, then just increment clock sequence
+ } else {
+ b := make([]byte, 2)
+ _, err := rand.Read(b)
+ if err != nil {
+ return nil, err
+ }
+ clockSequence = uint16(int(b[0])<<8 | int(b[1])) // set to a random value (network byte order)
+ }
+
+ lastGenerated = now // remember the last generated time
+
+ timeLow := uint32(timestamp & 0xffffffff)
+ timeMiddle := uint16((timestamp >> 32) & 0xffff)
+ timeHigh := uint16((timestamp >> 48) & 0xfff)
+
+ // network byte order(BigEndian)
+ binary.BigEndian.PutUint32(uuid[0:], timeLow)
+ binary.BigEndian.PutUint16(uuid[4:], timeMiddle)
+ binary.BigEndian.PutUint16(uuid[6:], timeHigh)
+ binary.BigEndian.PutUint16(uuid[8:], clockSequence)
+
+ // get node id(mac address)
+ if nodeID == nil {
+ interfaces, err := net.Interfaces()
+ if err != nil {
+ return nil, err
+ }
+
+ for _, i := range interfaces {
+ if len(i.HardwareAddr) >= 6 {
+ nodeID = make([]byte, 6)
+ copy(nodeID, i.HardwareAddr)
+ break
+ }
+ }
+
+ if nodeID == nil {
+ nodeID = make([]byte, 6)
+ _, err := rand.Read(nodeID)
+ if err != nil {
+ return nil, err
+ }
+ }
+ }
+
+ copy(uuid[10:], nodeID)
+
+ // set version(v1)
+ version.Set(uuid, version.TimeBased)
+ // set layout(RFC4122)
+ layout.Set(uuid, layout.RFC4122)
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/version/utility.go b/vendor/github.com/wayn3h0/go-uuid/internal/version/utility.go
new file mode 100644
index 0000000000000000000000000000000000000000..2862711a022e9f06fa763ea6546700e7765f2aed
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/version/utility.go
@@ -0,0 +1,29 @@
+package version
+
+// Set sets the version for uuid.
+func Set(uuid []byte, version Version) {
+ switch version {
+ case TimeBased:
+ uuid[6] = (uuid[6] | 0x10) & 0x1f
+ case DCESecurity:
+ uuid[6] = (uuid[6] | 0x20) & 0x2f
+ case NameBasedMD5:
+ uuid[6] = (uuid[6] | 0x30) & 0x3f
+ case Random:
+ uuid[6] = (uuid[6] | 0x40) & 0x4f
+ case NameBasedSHA1:
+ uuid[6] = (uuid[6] | 0x50) & 0x5f
+ default:
+ panic("uuid: version is unknown")
+ }
+}
+
+// Get gets the version of uuid.
+func Get(uuid []byte) Version {
+ version := uuid[6] >> 4
+ if version > 0 && version < 6 {
+ return Version(version)
+ }
+
+ return Unknown
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/internal/version/version.go b/vendor/github.com/wayn3h0/go-uuid/internal/version/version.go
new file mode 100644
index 0000000000000000000000000000000000000000..10ab52cfa15cde59be546f2c21dc49e24b79103c
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/internal/version/version.go
@@ -0,0 +1,14 @@
+package version
+
+// Version represents the version of UUID. See page 7 in RFC 4122.
+type Version byte
+
+// Version List
+const (
+ Unknown Version = iota // Unknwon
+ TimeBased // V1: The time-based version
+ DCESecurity // V2: The DCE security version, with embedded POSIX UIDs
+ NameBasedMD5 // V3: The name-based version that uses MD5 hashing
+ Random // V4: The randomly or pseudo-randomly generated version
+ NameBasedSHA1 // V5: The name-based version that uses SHA-1 hashing
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/layout.go b/vendor/github.com/wayn3h0/go-uuid/layout.go
new file mode 100644
index 0000000000000000000000000000000000000000..7656df5d163e6e15a85aeaef1d7ec9605d3885f0
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/layout.go
@@ -0,0 +1,33 @@
+package uuid
+
+import (
+ "github.com/wayn3h0/go-uuid/internal/layout"
+)
+
+// Layout represents the layout of UUID. See page 5 in RFC 4122.
+type Layout byte
+
+// Layouts.
+const (
+ LayoutInvalid = Layout(layout.Invalid) // Invalid
+ LayoutNCS = Layout(layout.NCS) // Reserved, NCS backward compatibility. (Values: 0x00-0x07)
+ LayoutRFC4122 = Layout(layout.RFC4122) // The variant specified in RFC 4122. (Values: 0x08-0x0b)
+ LayoutMicrosoft = Layout(layout.Microsoft) // Reserved, Microsoft Corporation backward compatibility. (Values: 0x0c-0x0d)
+ LayoutFuture = Layout(layout.Future) // Reserved for future definition. (Values: 0x0e-0x0f)
+)
+
+// String returns English description of layout.
+func (this Layout) String() string {
+ switch this {
+ case LayoutNCS:
+ return "Layout: Reserved For NCS"
+ case LayoutRFC4122:
+ return "Layout: RFC 4122"
+ case LayoutMicrosoft:
+ return "Layout: Reserved For Microsoft"
+ case LayoutFuture:
+ return "Layout: Reserved For Future"
+ default:
+ return "Layout: Invalid"
+ }
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/namespace.go b/vendor/github.com/wayn3h0/go-uuid/namespace.go
new file mode 100644
index 0000000000000000000000000000000000000000..23b314a56f84c63c6c9788a226d261d5b5545316
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/namespace.go
@@ -0,0 +1,13 @@
+package uuid
+
+import (
+ "github.com/wayn3h0/go-uuid/internal/namebased"
+)
+
+// Imports namespaces.
+const (
+ NamespaceDNS = namebased.NamespaceDNS // "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceURL = namebased.NamespaceURL // "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceOID = namebased.NamespaceOID // "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
+ NamespaceX500 = namebased.NamespaceX500 // "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
+)
diff --git a/vendor/github.com/wayn3h0/go-uuid/parse.go b/vendor/github.com/wayn3h0/go-uuid/parse.go
new file mode 100644
index 0000000000000000000000000000000000000000..0847299c3cede87a69dea74f44860003d34b2722
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/parse.go
@@ -0,0 +1,47 @@
+package uuid
+
+import (
+ "encoding/hex"
+ "errors"
+ "fmt"
+)
+
+// Parse parses the UUID string.
+func Parse(str string) (UUID, error) {
+ length := len(str)
+ buffer := make([]byte, 16)
+ charIndexes := []int{}
+ switch length {
+ case 36:
+ if str[8] != '-' || str[13] != '-' || str[18] != '-' || str[23] != '-' {
+ return Nil, fmt.Errorf("uuid: format of UUID string \"%s\" is invalid, it should be xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)", str)
+ }
+ charIndexes = []int{0, 2, 4, 6, 9, 11, 14, 16, 19, 21, 24, 26, 28, 30, 32, 34}
+ case 32:
+ charIndexes = []int{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}
+ default:
+ return Nil, fmt.Errorf("uuid: length of UUID string \"%s\" is invalid, it should be 36 (standard) or 32 (without dash)", str)
+ }
+ for i, v := range charIndexes {
+ if c, e := hex.DecodeString(str[v : v+2]); e != nil {
+ return Nil, fmt.Errorf("uuid: UUID string \"%s\" is invalid: %s", str, e.Error())
+ } else {
+ buffer[i] = c[0]
+ }
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], buffer)
+
+ if !uuid.Equal(Nil) {
+ if uuid.Layout() == LayoutInvalid {
+ return Nil, errors.New("uuid: layout is invalid")
+ }
+
+ if uuid.Version() == VersionUnknown {
+ return Nil, errors.New("uuid: version is unknown")
+ }
+ }
+
+ return uuid, nil
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/style.go b/vendor/github.com/wayn3h0/go-uuid/style.go
new file mode 100644
index 0000000000000000000000000000000000000000..17b816a75c1d1b9ce8c7142b15a7fbbc527d6597
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/style.go
@@ -0,0 +1,22 @@
+package uuid
+
+// Style represents the style of UUID string.
+type Style byte
+
+// Styles.
+const (
+ StyleStandard Style = iota + 1 // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12, length: 36)
+ StyleWithoutDash // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx (length: 32)
+)
+
+// String returns English description of style.
+func (this Style) String() string {
+ switch this {
+ case StyleStandard:
+ return "Style: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)"
+ case StyleWithoutDash:
+ return "Style: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ default:
+ return "Style: Unknown"
+ }
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/uuid.go b/vendor/github.com/wayn3h0/go-uuid/uuid.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea17ec284621868df10e5b288a28ccb1b7a8476b
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/uuid.go
@@ -0,0 +1,147 @@
+package uuid
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/wayn3h0/go-uuid/internal/dcesecurity"
+ "github.com/wayn3h0/go-uuid/internal/layout"
+ "github.com/wayn3h0/go-uuid/internal/namebased/md5"
+ "github.com/wayn3h0/go-uuid/internal/namebased/sha1"
+ "github.com/wayn3h0/go-uuid/internal/random"
+ "github.com/wayn3h0/go-uuid/internal/timebased"
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+var (
+ Nil = UUID{} // Nil UUID
+)
+
+// NewTimeBased returns a new time based UUID (version 1).
+func NewTimeBased() (UUID, error) {
+ u, err := timebased.New()
+ if err != nil {
+ return Nil, err
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], u)
+
+ return uuid, nil
+}
+
+// NewV1 same as NewTimeBased.
+func NewV1() (UUID, error) {
+ return NewTimeBased()
+}
+
+// NewDCESecurity returns a new DCE security UUID (version 2).
+func NewDCESecurity(domain Domain) (UUID, error) {
+ u, err := dcesecurity.New(dcesecurity.Domain(domain))
+ if err != nil {
+ return Nil, err
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], u)
+
+ return uuid, nil
+}
+
+// NewV2 same as NewDCESecurity.
+func NewV2(domain Domain) (UUID, error) {
+ return NewDCESecurity(domain)
+}
+
+// NewNameBasedMD5 returns a new name based UUID with MD5 hash (version 3).
+func NewNameBasedMD5(namespace, name string) (UUID, error) {
+ u, err := md5.New(namespace, name)
+ if err != nil {
+ return Nil, err
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], u)
+
+ return uuid, nil
+}
+
+// NewV3 same as NewNameBasedMD5.
+func NewV3(namespace, name string) (UUID, error) {
+ return NewNameBasedMD5(namespace, name)
+}
+
+// NewRandom returns a new random UUID (version 4).
+func NewRandom() (UUID, error) {
+ u, err := random.New()
+ if err != nil {
+ return Nil, err
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], u)
+
+ return uuid, nil
+}
+
+// NewV4 same as NewRandom.
+func NewV4() (UUID, error) {
+ return NewRandom()
+}
+
+// New same as NewRandom.
+func New() (UUID, error) {
+ return NewRandom()
+}
+
+// NewNameBasedSHA1 returns a new name based UUID with SHA1 hash (version 5).
+func NewNameBasedSHA1(namespace, name string) (UUID, error) {
+ u, err := sha1.New(namespace, name)
+ if err != nil {
+ return Nil, err
+ }
+
+ uuid := UUID{}
+ copy(uuid[:], u)
+
+ return uuid, nil
+}
+
+// NewV5 same as NewNameBasedSHA1.
+func NewV5(namespace, name string) (UUID, error) {
+ return NewNameBasedSHA1(namespace, name)
+}
+
+// UUID respresents an UUID type compliant with specification in RFC 4122.
+type UUID [16]byte
+
+// Layout returns layout of UUID.
+func (this UUID) Layout() Layout {
+ return Layout(layout.Get(this[:]))
+}
+
+// Version returns version of UUID.
+func (this UUID) Version() Version {
+ return Version(version.Get(this[:]))
+}
+
+// Equal returns true if current uuid equal to passed uuid.
+func (this UUID) Equal(another UUID) bool {
+ return bytes.EqualFold(this[:], another[:])
+}
+
+// Format returns the formatted string of UUID.
+func (this UUID) Format(style Style) string {
+ switch style {
+ case StyleWithoutDash:
+ return fmt.Sprintf("%x", this[:])
+ //case StyleStandard:
+ default:
+ return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", this[:4], this[4:6], this[6:8], this[8:10], this[10:])
+ }
+}
+
+// String returns the string of UUID with standard style(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | 8-4-4-4-12).
+func (this UUID) String() string {
+ return this.Format(StyleStandard)
+}
diff --git a/vendor/github.com/wayn3h0/go-uuid/version.go b/vendor/github.com/wayn3h0/go-uuid/version.go
new file mode 100644
index 0000000000000000000000000000000000000000..af509e3a3bb170dc45576c415d38f3c6f0444ffe
--- /dev/null
+++ b/vendor/github.com/wayn3h0/go-uuid/version.go
@@ -0,0 +1,45 @@
+package uuid
+
+import (
+ "github.com/wayn3h0/go-uuid/internal/version"
+)
+
+// Version represents the version of UUID. See page 7 in RFC 4122.
+type Version byte
+
+// Versions.
+const (
+ VersionUnknown = Version(version.Unknown) // Unknown
+ VersionTimeBased = Version(version.TimeBased) // V1: The time-based version
+ VersionDCESecurity = Version(version.DCESecurity) // V2: The DCE security version, with embedded POSIX UIDs
+ VersionNameBasedMD5 = Version(version.NameBasedMD5) // V3: The name-based version that uses MD5 hashing
+ VersionRandom = Version(version.Random) // V4: The randomly or pseudo-randomly generated version
+ VersionNameBasedSHA1 = Version(version.NameBasedSHA1) // V5: The name-based version that uses SHA-1 hashing
+)
+
+// Short names.
+const (
+ V1 = VersionTimeBased
+ V2 = VersionDCESecurity
+ V3 = VersionNameBasedMD5
+ V4 = VersionRandom
+ V5 = VersionNameBasedSHA1
+)
+
+// String returns English description of version.
+func (this Version) String() string {
+ switch this {
+ case VersionTimeBased:
+ return "Version 1: Time-Based"
+ case VersionDCESecurity:
+ return "Version 2: DCE Security With Embedded POSIX UIDs"
+ case VersionNameBasedMD5:
+ return "Version 3: Name-Based (MD5)"
+ case VersionRandom:
+ return "Version 4: Randomly OR Pseudo-Randomly Generated"
+ case VersionNameBasedSHA1:
+ return "Version 5: Name-Based (SHA-1)"
+ default:
+ return "Version: Unknown"
+ }
+}