| // Copyright (C) MongoDB, Inc. 2017-present. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may |
| // not use this file except in compliance with the License. You may obtain |
| // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer |
| // See THIRD-PARTY-NOTICES for original license terms. |
| |
| package primitive |
| |
| import ( |
| "bytes" |
| "crypto/rand" |
| "encoding/binary" |
| "encoding/hex" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "sync/atomic" |
| "time" |
| ) |
| |
| // ErrInvalidHex indicates that a hex string cannot be converted to an ObjectID. |
| var ErrInvalidHex = errors.New("the provided hex string is not a valid ObjectID") |
| |
| // ObjectID is the BSON ObjectID type. |
| type ObjectID [12]byte |
| |
| // NilObjectID is the zero value for ObjectID. |
| var NilObjectID ObjectID |
| |
| var objectIDCounter = readRandomUint32() |
| var processUnique = processUniqueBytes() |
| |
| // NewObjectID generates a new ObjectID. |
| func NewObjectID() ObjectID { |
| var b [12]byte |
| |
| binary.BigEndian.PutUint32(b[0:4], uint32(time.Now().Unix())) |
| copy(b[4:9], processUnique[:]) |
| putUint24(b[9:12], atomic.AddUint32(&objectIDCounter, 1)) |
| |
| return b |
| } |
| |
| // Hex returns the hex encoding of the ObjectID as a string. |
| func (id ObjectID) Hex() string { |
| return hex.EncodeToString(id[:]) |
| } |
| |
| func (id ObjectID) String() string { |
| return fmt.Sprintf("ObjectID(%q)", id.Hex()) |
| } |
| |
| // IsZero returns true if id is the empty ObjectID. |
| func (id ObjectID) IsZero() bool { |
| return bytes.Equal(id[:], NilObjectID[:]) |
| } |
| |
| // ObjectIDFromHex creates a new ObjectID from a hex string. It returns an error if the hex string is not a |
| // valid ObjectID. |
| func ObjectIDFromHex(s string) (ObjectID, error) { |
| b, err := hex.DecodeString(s) |
| if err != nil { |
| return NilObjectID, err |
| } |
| |
| if len(b) != 12 { |
| return NilObjectID, ErrInvalidHex |
| } |
| |
| var oid [12]byte |
| copy(oid[:], b[:]) |
| |
| return oid, nil |
| } |
| |
| // MarshalJSON returns the ObjectID as a string |
| func (id ObjectID) MarshalJSON() ([]byte, error) { |
| return json.Marshal(id.Hex()) |
| } |
| |
| // UnmarshalJSON populates the byte slice with the ObjectID. If the byte slice is 64 bytes long, it |
| // will be populated with the hex representation of the ObjectID. If the byte slice is twelve bytes |
| // long, it will be populated with the BSON representation of the ObjectID. Otherwise, it will |
| // return an error. |
| func (id *ObjectID) UnmarshalJSON(b []byte) error { |
| var err error |
| switch len(b) { |
| case 12: |
| copy(id[:], b) |
| default: |
| // Extended JSON |
| var res interface{} |
| err := json.Unmarshal(b, &res) |
| if err != nil { |
| return err |
| } |
| str, ok := res.(string) |
| if !ok { |
| m, ok := res.(map[string]interface{}) |
| if !ok { |
| return errors.New("not an extended JSON ObjectID") |
| } |
| oid, ok := m["$oid"] |
| if !ok { |
| return errors.New("not an extended JSON ObjectID") |
| } |
| str, ok = oid.(string) |
| if !ok { |
| return errors.New("not an extended JSON ObjectID") |
| } |
| } |
| |
| if len(str) != 24 { |
| return fmt.Errorf("cannot unmarshal into an ObjectID, the length must be 12 but it is %d", len(str)) |
| } |
| |
| _, err = hex.Decode(id[:], []byte(str)) |
| if err != nil { |
| return err |
| } |
| } |
| |
| return err |
| } |
| |
| func processUniqueBytes() [5]byte { |
| var b [5]byte |
| _, err := io.ReadFull(rand.Reader, b[:]) |
| if err != nil { |
| panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err)) |
| } |
| |
| return b |
| } |
| |
| func readRandomUint32() uint32 { |
| var b [4]byte |
| _, err := io.ReadFull(rand.Reader, b[:]) |
| if err != nil { |
| panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err)) |
| } |
| |
| return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24) |
| } |
| |
| func putUint24(b []byte, v uint32) { |
| b[0] = byte(v >> 16) |
| b[1] = byte(v >> 8) |
| b[2] = byte(v) |
| } |