132 lines
2.8 KiB
Go
132 lines
2.8 KiB
Go
package actor
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
type GrainId uint64
|
|
|
|
const base62Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
|
|
// Reverse lookup (0xFF marks invalid)
|
|
var base62Rev [256]byte
|
|
|
|
func init() {
|
|
for i := range base62Rev {
|
|
base62Rev[i] = 0xFF
|
|
}
|
|
for i := 0; i < len(base62Alphabet); i++ {
|
|
base62Rev[base62Alphabet[i]] = byte(i)
|
|
}
|
|
}
|
|
|
|
// String returns the canonical base62 encoding of the 64-bit id.
|
|
func (id GrainId) String() string {
|
|
return encodeBase62(uint64(id))
|
|
}
|
|
|
|
// MarshalJSON encodes the cart id as a JSON string.
|
|
func (id GrainId) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(id.String())
|
|
}
|
|
|
|
// UnmarshalJSON decodes a cart id from a JSON string containing base62 text.
|
|
func (id *GrainId) UnmarshalJSON(data []byte) error {
|
|
var s string
|
|
if err := json.Unmarshal(data, &s); err != nil {
|
|
return err
|
|
}
|
|
parsed, ok := ParseGrainId(s)
|
|
if !ok {
|
|
return fmt.Errorf("invalid cart id: %q", s)
|
|
}
|
|
*id = parsed
|
|
return nil
|
|
}
|
|
|
|
// NewGrainId generates a new cryptographically random non-zero 64-bit id.
|
|
func NewGrainId() (GrainId, error) {
|
|
var b [8]byte
|
|
if _, err := rand.Read(b[:]); err != nil {
|
|
return 0, fmt.Errorf("NewGrainId: %w", err)
|
|
}
|
|
u := (uint64(b[0]) << 56) |
|
|
(uint64(b[1]) << 48) |
|
|
(uint64(b[2]) << 40) |
|
|
(uint64(b[3]) << 32) |
|
|
(uint64(b[4]) << 24) |
|
|
(uint64(b[5]) << 16) |
|
|
(uint64(b[6]) << 8) |
|
|
uint64(b[7])
|
|
if u == 0 {
|
|
// Extremely unlikely; regenerate once to avoid "0" identifier if desired.
|
|
return NewGrainId()
|
|
}
|
|
return GrainId(u), nil
|
|
}
|
|
|
|
// MustNewGrainId panics if generation fails.
|
|
func MustNewGrainId() GrainId {
|
|
id, err := NewGrainId()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
// ParseGrainId parses a base62 string into a GrainId.
|
|
// Returns (0,false) for invalid input.
|
|
func ParseGrainId(s string) (GrainId, bool) {
|
|
// Accept length 1..11 (11 sufficient for 64 bits). Reject >11 immediately.
|
|
// Provide a slightly looser upper bound (<=16) only if you anticipate future
|
|
// extensions; here we stay strict.
|
|
if len(s) == 0 || len(s) > 11 {
|
|
return 0, false
|
|
}
|
|
u, ok := decodeBase62(s)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
return GrainId(u), true
|
|
}
|
|
|
|
// MustParseGrainId panics on invalid base62 input.
|
|
func MustParseGrainId(s string) GrainId {
|
|
id, ok := ParseGrainId(s)
|
|
if !ok {
|
|
panic(fmt.Sprintf("invalid cart id: %q", s))
|
|
}
|
|
return id
|
|
}
|
|
|
|
// encodeBase62 converts a uint64 to base62 (shortest form).
|
|
func encodeBase62(u uint64) string {
|
|
if u == 0 {
|
|
return "0"
|
|
}
|
|
var buf [11]byte
|
|
i := len(buf)
|
|
for u > 0 {
|
|
i--
|
|
buf[i] = base62Alphabet[u%62]
|
|
u /= 62
|
|
}
|
|
return string(buf[i:])
|
|
}
|
|
|
|
// decodeBase62 converts base62 text to uint64.
|
|
func decodeBase62(s string) (uint64, bool) {
|
|
var v uint64
|
|
for i := 0; i < len(s); i++ {
|
|
c := s[i]
|
|
d := base62Rev[c]
|
|
if d == 0xFF {
|
|
return 0, false
|
|
}
|
|
v = v*62 + uint64(d)
|
|
}
|
|
return v, true
|
|
}
|