diff options
Diffstat (limited to 'vendor/github.com/satori/go.uuid/codec.go')
-rw-r--r-- | vendor/github.com/satori/go.uuid/codec.go | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/vendor/github.com/satori/go.uuid/codec.go b/vendor/github.com/satori/go.uuid/codec.go new file mode 100644 index 0000000..656892c --- /dev/null +++ b/vendor/github.com/satori/go.uuid/codec.go | |||
@@ -0,0 +1,206 @@ | |||
1 | // Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru> | ||
2 | // | ||
3 | // Permission is hereby granted, free of charge, to any person obtaining | ||
4 | // a copy of this software and associated documentation files (the | ||
5 | // "Software"), to deal in the Software without restriction, including | ||
6 | // without limitation the rights to use, copy, modify, merge, publish, | ||
7 | // distribute, sublicense, and/or sell copies of the Software, and to | ||
8 | // permit persons to whom the Software is furnished to do so, subject to | ||
9 | // the following conditions: | ||
10 | // | ||
11 | // The above copyright notice and this permission notice shall be | ||
12 | // included in all copies or substantial portions of the Software. | ||
13 | // | ||
14 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
15 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
16 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
17 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | ||
18 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | ||
19 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | ||
20 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
21 | |||
22 | package uuid | ||
23 | |||
24 | import ( | ||
25 | "bytes" | ||
26 | "encoding/hex" | ||
27 | "fmt" | ||
28 | ) | ||
29 | |||
30 | // FromBytes returns UUID converted from raw byte slice input. | ||
31 | // It will return error if the slice isn't 16 bytes long. | ||
32 | func FromBytes(input []byte) (u UUID, err error) { | ||
33 | err = u.UnmarshalBinary(input) | ||
34 | return | ||
35 | } | ||
36 | |||
37 | // FromBytesOrNil returns UUID converted from raw byte slice input. | ||
38 | // Same behavior as FromBytes, but returns a Nil UUID on error. | ||
39 | func FromBytesOrNil(input []byte) UUID { | ||
40 | uuid, err := FromBytes(input) | ||
41 | if err != nil { | ||
42 | return Nil | ||
43 | } | ||
44 | return uuid | ||
45 | } | ||
46 | |||
47 | // FromString returns UUID parsed from string input. | ||
48 | // Input is expected in a form accepted by UnmarshalText. | ||
49 | func FromString(input string) (u UUID, err error) { | ||
50 | err = u.UnmarshalText([]byte(input)) | ||
51 | return | ||
52 | } | ||
53 | |||
54 | // FromStringOrNil returns UUID parsed from string input. | ||
55 | // Same behavior as FromString, but returns a Nil UUID on error. | ||
56 | func FromStringOrNil(input string) UUID { | ||
57 | uuid, err := FromString(input) | ||
58 | if err != nil { | ||
59 | return Nil | ||
60 | } | ||
61 | return uuid | ||
62 | } | ||
63 | |||
64 | // MarshalText implements the encoding.TextMarshaler interface. | ||
65 | // The encoding is the same as returned by String. | ||
66 | func (u UUID) MarshalText() (text []byte, err error) { | ||
67 | text = []byte(u.String()) | ||
68 | return | ||
69 | } | ||
70 | |||
71 | // UnmarshalText implements the encoding.TextUnmarshaler interface. | ||
72 | // Following formats are supported: | ||
73 | // "6ba7b810-9dad-11d1-80b4-00c04fd430c8", | ||
74 | // "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}", | ||
75 | // "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" | ||
76 | // "6ba7b8109dad11d180b400c04fd430c8" | ||
77 | // ABNF for supported UUID text representation follows: | ||
78 | // uuid := canonical | hashlike | braced | urn | ||
79 | // plain := canonical | hashlike | ||
80 | // canonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct | ||
81 | // hashlike := 12hexoct | ||
82 | // braced := '{' plain '}' | ||
83 | // urn := URN ':' UUID-NID ':' plain | ||
84 | // URN := 'urn' | ||
85 | // UUID-NID := 'uuid' | ||
86 | // 12hexoct := 6hexoct 6hexoct | ||
87 | // 6hexoct := 4hexoct 2hexoct | ||
88 | // 4hexoct := 2hexoct 2hexoct | ||
89 | // 2hexoct := hexoct hexoct | ||
90 | // hexoct := hexdig hexdig | ||
91 | // hexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | | ||
92 | // 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | | ||
93 | // 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | ||
94 | func (u *UUID) UnmarshalText(text []byte) (err error) { | ||
95 | switch len(text) { | ||
96 | case 32: | ||
97 | return u.decodeHashLike(text) | ||
98 | case 36: | ||
99 | return u.decodeCanonical(text) | ||
100 | case 38: | ||
101 | return u.decodeBraced(text) | ||
102 | case 41: | ||
103 | fallthrough | ||
104 | case 45: | ||
105 | return u.decodeURN(text) | ||
106 | default: | ||
107 | return fmt.Errorf("uuid: incorrect UUID length: %s", text) | ||
108 | } | ||
109 | } | ||
110 | |||
111 | // decodeCanonical decodes UUID string in format | ||
112 | // "6ba7b810-9dad-11d1-80b4-00c04fd430c8". | ||
113 | func (u *UUID) decodeCanonical(t []byte) (err error) { | ||
114 | if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' { | ||
115 | return fmt.Errorf("uuid: incorrect UUID format %s", t) | ||
116 | } | ||
117 | |||
118 | src := t[:] | ||
119 | dst := u[:] | ||
120 | |||
121 | for i, byteGroup := range byteGroups { | ||
122 | if i > 0 { | ||
123 | src = src[1:] // skip dash | ||
124 | } | ||
125 | _, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup]) | ||
126 | if err != nil { | ||
127 | return | ||
128 | } | ||
129 | src = src[byteGroup:] | ||
130 | dst = dst[byteGroup/2:] | ||
131 | } | ||
132 | |||
133 | return | ||
134 | } | ||
135 | |||
136 | // decodeHashLike decodes UUID string in format | ||
137 | // "6ba7b8109dad11d180b400c04fd430c8". | ||
138 | func (u *UUID) decodeHashLike(t []byte) (err error) { | ||
139 | src := t[:] | ||
140 | dst := u[:] | ||
141 | |||
142 | if _, err = hex.Decode(dst, src); err != nil { | ||
143 | return err | ||
144 | } | ||
145 | return | ||
146 | } | ||
147 | |||
148 | // decodeBraced decodes UUID string in format | ||
149 | // "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" or in format | ||
150 | // "{6ba7b8109dad11d180b400c04fd430c8}". | ||
151 | func (u *UUID) decodeBraced(t []byte) (err error) { | ||
152 | l := len(t) | ||
153 | |||
154 | if t[0] != '{' || t[l-1] != '}' { | ||
155 | return fmt.Errorf("uuid: incorrect UUID format %s", t) | ||
156 | } | ||
157 | |||
158 | return u.decodePlain(t[1 : l-1]) | ||
159 | } | ||
160 | |||
161 | // decodeURN decodes UUID string in format | ||
162 | // "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in format | ||
163 | // "urn:uuid:6ba7b8109dad11d180b400c04fd430c8". | ||
164 | func (u *UUID) decodeURN(t []byte) (err error) { | ||
165 | total := len(t) | ||
166 | |||
167 | urn_uuid_prefix := t[:9] | ||
168 | |||
169 | if !bytes.Equal(urn_uuid_prefix, urnPrefix) { | ||
170 | return fmt.Errorf("uuid: incorrect UUID format: %s", t) | ||
171 | } | ||
172 | |||
173 | return u.decodePlain(t[9:total]) | ||
174 | } | ||
175 | |||
176 | // decodePlain decodes UUID string in canonical format | ||
177 | // "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format | ||
178 | // "6ba7b8109dad11d180b400c04fd430c8". | ||
179 | func (u *UUID) decodePlain(t []byte) (err error) { | ||
180 | switch len(t) { | ||
181 | case 32: | ||
182 | return u.decodeHashLike(t) | ||
183 | case 36: | ||
184 | return u.decodeCanonical(t) | ||
185 | default: | ||
186 | return fmt.Errorf("uuid: incorrrect UUID length: %s", t) | ||
187 | } | ||
188 | } | ||
189 | |||
190 | // MarshalBinary implements the encoding.BinaryMarshaler interface. | ||
191 | func (u UUID) MarshalBinary() (data []byte, err error) { | ||
192 | data = u.Bytes() | ||
193 | return | ||
194 | } | ||
195 | |||
196 | // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. | ||
197 | // It will return error if the slice isn't 16 bytes long. | ||
198 | func (u *UUID) UnmarshalBinary(data []byte) (err error) { | ||
199 | if len(data) != Size { | ||
200 | err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data)) | ||
201 | return | ||
202 | } | ||
203 | copy(u[:], data) | ||
204 | |||
205 | return | ||
206 | } | ||