Naveen Sampath | 04696f7 | 2022-06-13 15:19:14 +0530 | [diff] [blame^] | 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 | } |