| 1 |
// Copyright 2016 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 |
"encoding/binary" |
| 9 |
"sync" |
| 10 |
"time" |
| 11 |
) |
| 12 |
|
| 13 |
// A Time represents a time as the number of 100's of nanoseconds since 15 Oct |
| 14 |
// 1582. |
| 15 |
type Time int64 |
| 16 |
|
| 17 |
const ( |
| 18 |
lillian = 2299160 // Julian day of 15 Oct 1582 |
| 19 |
unix = 2440587 // Julian day of 1 Jan 1970 |
| 20 |
epoch = unix - lillian // Days between epochs |
| 21 |
g1582 = epoch * 86400 // seconds between epochs |
| 22 |
g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs |
| 23 |
) |
| 24 |
|
| 25 |
var ( |
| 26 |
timeMu sync.Mutex |
| 27 |
lasttime uint64 // last time we returned |
| 28 |
clockSeq uint16 // clock sequence for this run |
| 29 |
|
| 30 |
timeNow = time.Now // for testing |
| 31 |
) |
| 32 |
|
| 33 |
// UnixTime converts t the number of seconds and nanoseconds using the Unix |
| 34 |
// epoch of 1 Jan 1970. |
| 35 |
func (t Time) UnixTime() (sec, nsec int64) { |
| 36 |
sec = int64(t - g1582ns100) |
| 37 |
nsec = (sec % 10000000) * 100 |
| 38 |
sec /= 10000000 |
| 39 |
return sec, nsec |
| 40 |
} |
| 41 |
|
| 42 |
// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and |
| 43 |
// clock sequence as well as adjusting the clock sequence as needed. An error |
| 44 |
// is returned if the current time cannot be determined. |
| 45 |
func GetTime() (Time, uint16, error) { |
| 46 |
defer timeMu.Unlock() |
| 47 |
timeMu.Lock() |
| 48 |
return getTime() |
| 49 |
} |
| 50 |
|
| 51 |
func getTime() (Time, uint16, error) { |
| 52 |
t := timeNow() |
| 53 |
|
| 54 |
// If we don't have a clock sequence already, set one. |
| 55 |
if clockSeq == 0 { |
| 56 |
setClockSequence(-1) |
| 57 |
} |
| 58 |
now := uint64(t.UnixNano()/100) + g1582ns100 |
| 59 |
|
| 60 |
// If time has gone backwards with this clock sequence then we |
| 61 |
// increment the clock sequence |
| 62 |
if now <= lasttime { |
| 63 |
clockSeq = ((clockSeq + 1) & 0x3fff) | 0x8000 |
| 64 |
} |
| 65 |
lasttime = now |
| 66 |
return Time(now), clockSeq, nil |
| 67 |
} |
| 68 |
|
| 69 |
// ClockSequence returns the current clock sequence, generating one if not |
| 70 |
// already set. The clock sequence is only used for Version 1 UUIDs. |
| 71 |
// |
| 72 |
// The uuid package does not use global static storage for the clock sequence or |
| 73 |
// the last time a UUID was generated. Unless SetClockSequence is used, a new |
| 74 |
// random clock sequence is generated the first time a clock sequence is |
| 75 |
// requested by ClockSequence, GetTime, or NewUUID. (section 4.2.1.1) |
| 76 |
func ClockSequence() int { |
| 77 |
defer timeMu.Unlock() |
| 78 |
timeMu.Lock() |
| 79 |
return clockSequence() |
| 80 |
} |
| 81 |
|
| 82 |
func clockSequence() int { |
| 83 |
if clockSeq == 0 { |
| 84 |
setClockSequence(-1) |
| 85 |
} |
| 86 |
return int(clockSeq & 0x3fff) |
| 87 |
} |
| 88 |
|
| 89 |
// SetClockSequence sets the clock sequence to the lower 14 bits of seq. Setting to |
| 90 |
// -1 causes a new sequence to be generated. |
| 91 |
func SetClockSequence(seq int) { |
| 92 |
defer timeMu.Unlock() |
| 93 |
timeMu.Lock() |
| 94 |
setClockSequence(seq) |
| 95 |
} |
| 96 |
|
| 97 |
func setClockSequence(seq int) { |
| 98 |
if seq == -1 { |
| 99 |
var b [2]byte |
| 100 |
randomBits(b[:]) // clock sequence |
| 101 |
seq = int(b[0])<<8 | int(b[1]) |
| 102 |
} |
| 103 |
oldSeq := clockSeq |
| 104 |
clockSeq = uint16(seq&0x3fff) | 0x8000 // Set our variant |
| 105 |
if oldSeq != clockSeq { |
| 106 |
lasttime = 0 |
| 107 |
} |
| 108 |
} |
| 109 |
|
| 110 |
// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in |
| 111 |
// uuid. The time is only defined for version 1 and 2 UUIDs. |
| 112 |
func (uuid UUID) Time() Time { |
| 113 |
time := int64(binary.BigEndian.Uint32(uuid[0:4])) |
| 114 |
time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32 |
| 115 |
time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48 |
| 116 |
return Time(time) |
| 117 |
} |
| 118 |
|
| 119 |
// ClockSequence returns the clock sequence encoded in uuid. |
| 120 |
// The clock sequence is only well defined for version 1 and 2 UUIDs. |
| 121 |
func (uuid UUID) ClockSequence() int { |
| 122 |
return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff |
| 123 |
} |