Debian Codegraph @

v5/vendor/github.com/pborman/uuid/uuid.go

raw
1 // Copyright 2011 Google Inc. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package uuid
6
7 import (
8 "bytes"
9 "crypto/rand"
10 "encoding/hex"
11 "io"
12
13 guuid "github.com/google/uuid"
14 )
15
16 // Array is a pass-by-value UUID that can be used as an effecient key in a map.
17 type Array [16]byte
18
19 // UUID converts uuid into a slice.
20 func (uuid Array) UUID() UUID {
21 return uuid[:]
22 }
23
24 // String returns the string representation of uuid,
25 // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
26 func (uuid Array) String() string {
27 return guuid.UUID(uuid).String()
28 }
29
30 // A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
31 // 4122.
32 type UUID []byte
33
34 // A Version represents a UUIDs version.
35 type Version = guuid.Version
36
37 // A Variant represents a UUIDs variant.
38 type Variant = guuid.Variant
39
40 // Constants returned by Variant.
41 const (
42 Invalid = guuid.Invalid // Invalid UUID
43 RFC4122 = guuid.RFC4122 // The variant specified in RFC4122
44 Reserved = guuid.Reserved // Reserved, NCS backward compatibility.
45 Microsoft = guuid.Microsoft // Reserved, Microsoft Corporation backward compatibility.
46 Future = guuid.Future // Reserved for future definition.
47 )
48
49 var rander = rand.Reader // random function
50
51 // New returns a new random (version 4) UUID as a string. It is a convenience
52 // function for NewRandom().String().
53 func New() string {
54 return NewRandom().String()
55 }
56
57 // Parse decodes s into a UUID or returns nil. See github.com/google/uuid for
58 // the formats parsed.
59 func Parse(s string) UUID {
60 gu, err := guuid.Parse(s)
61 if err == nil {
62 return gu[:]
63 }
64 return nil
65 }
66
67 // ParseBytes is like Parse, except it parses a byte slice instead of a string.
68 func ParseBytes(b []byte) (UUID, error) {
69 gu, err := guuid.ParseBytes(b)
70 if err == nil {
71 return gu[:], nil
72 }
73 return nil, err
74 }
75
76 // Equal returns true if uuid1 and uuid2 are equal.
77 func Equal(uuid1, uuid2 UUID) bool {
78 return bytes.Equal(uuid1, uuid2)
79 }
80
81 // Array returns an array representation of uuid that can be used as a map key.
82 // Array panics if uuid is not valid.
83 func (uuid UUID) Array() Array {
84 if len(uuid) != 16 {
85 panic("invalid uuid")
86 }
87 var a Array
88 copy(a[:], uuid)
89 return a
90 }
91
92 // String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
93 // , or "" if uuid is invalid.
94 func (uuid UUID) String() string {
95 if len(uuid) != 16 {
96 return ""
97 }
98 var buf [36]byte
99 encodeHex(buf[:], uuid)
100 return string(buf[:])
101 }
102
103 // URN returns the RFC 2141 URN form of uuid,
104 // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, or "" if uuid is invalid.
105 func (uuid UUID) URN() string {
106 if len(uuid) != 16 {
107 return ""
108 }
109 var buf [36 + 9]byte
110 copy(buf[:], "urn:uuid:")
111 encodeHex(buf[9:], uuid)
112 return string(buf[:])
113 }
114
115 func encodeHex(dst []byte, uuid UUID) {
116 hex.Encode(dst[:], uuid[:4])
117 dst[8] = '-'
118 hex.Encode(dst[9:13], uuid[4:6])
119 dst[13] = '-'
120 hex.Encode(dst[14:18], uuid[6:8])
121 dst[18] = '-'
122 hex.Encode(dst[19:23], uuid[8:10])
123 dst[23] = '-'
124 hex.Encode(dst[24:], uuid[10:])
125 }
126
127 // Variant returns the variant encoded in uuid. It returns Invalid if
128 // uuid is invalid.
129 func (uuid UUID) Variant() Variant {
130 if len(uuid) != 16 {
131 return Invalid
132 }
133 switch {
134 case (uuid[8] & 0xc0) == 0x80:
135 return RFC4122
136 case (uuid[8] & 0xe0) == 0xc0:
137 return Microsoft
138 case (uuid[8] & 0xe0) == 0xe0:
139 return Future
140 default:
141 return Reserved
142 }
143 }
144
145 // Version returns the version of uuid. It returns false if uuid is not
146 // valid.
147 func (uuid UUID) Version() (Version, bool) {
148 if len(uuid) != 16 {
149 return 0, false
150 }
151 return Version(uuid[6] >> 4), true
152 }
153
154 // SetRand sets the random number generator to r, which implements io.Reader.
155 // If r.Read returns an error when the package requests random data then
156 // a panic will be issued.
157 //
158 // Calling SetRand with nil sets the random number generator to the default
159 // generator.
160 func SetRand(r io.Reader) {
161 guuid.SetRand(r)
162 }