oid.h

// oid.h

/*    Copyright 2009 10gen Inc.
 *
 *    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
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#pragma once

#include <string>

#include "mongo/base/data_view.h"
#include "mongo/bson/util/builder.h"
#include "mongo/client/export_macros.h"
#include "mongo/util/time_support.h"

namespace mongo {
class SecureRandom;

class MONGO_CLIENT_API OID {
public:
    struct Hasher {
        size_t operator()(const OID& oid) const;
    };

    OID() : _data() {}

    enum { kOIDSize = 12, kTimestampSize = 4, kInstanceUniqueSize = 5, kIncrementSize = 3 };

    explicit OID(const std::string& s) {
        init(s);
    }

    explicit OID(const unsigned char(&arr)[kOIDSize]) {
        std::memcpy(_data, arr, sizeof(arr));
    }

    void clear() {
        std::memset(_data, 0, kOIDSize);
    }

    int compare(const OID& other) const {
        return memcmp(_data, other._data, kOIDSize);
    }

    std::string toString() const;
    std::string toIncString() const;

    static OID MONGO_CLIENT_FUNC gen() {
        OID o((no_initialize_tag()));
        o.init();
        return o;
    }

    // Caller must ensure that the buffer is valid for kOIDSize bytes.
    // this is templated because some places use unsigned char vs signed char
    template <typename T>
    static OID MONGO_CLIENT_FUNC from(T* buf) {
        OID o((no_initialize_tag()));
        std::memcpy(o._data, buf, OID::kOIDSize);
        return o;
    }

    static OID MONGO_CLIENT_FUNC max() {
        OID o((no_initialize_tag()));
        std::memset(o._data, 0xFF, kOIDSize);
        return o;
    }

    void init();

    void init(const std::string& s);

    void init(Date_t date, bool max = false);

    time_t asTimeT() const;
    Date_t asDateT() const {
        return asTimeT() * 1000LL;
    }

    // True iff the OID is not empty
    bool isSet() const {
        return compare(OID()) != 0;
    }

    void hash_combine(size_t& seed) const;

    static void MONGO_CLIENT_FUNC justForked();

    static unsigned MONGO_CLIENT_FUNC getMachineId();  // used by the 'features' command
    static void MONGO_CLIENT_FUNC regenMachineId();

    // Timestamp is 4 bytes so we just use int32_t
    typedef int32_t Timestamp;

    // Wrappers so we can return stuff by value.
    struct InstanceUnique {
        static InstanceUnique MONGO_CLIENT_FUNC generate(SecureRandom& entropy);
        uint8_t bytes[kInstanceUniqueSize];
    };

    struct Increment {
    public:
        static Increment MONGO_CLIENT_FUNC next();
        uint8_t bytes[kIncrementSize];
    };

    void setTimestamp(Timestamp timestamp);
    void setInstanceUnique(InstanceUnique unique);
    void setIncrement(Increment inc);

    Timestamp getTimestamp() const;
    InstanceUnique getInstanceUnique() const;
    Increment getIncrement() const;

    ConstDataView view() const {
        return ConstDataView(_data);
    }

private:
    // Internal mutable view
    DataView _view() {
        return DataView(_data);
    }

    // When we are going to immediately overwrite the bytes, there is no point in zero
    // initializing the data first.
    struct no_initialize_tag {};
    explicit OID(no_initialize_tag) {}

    char _data[kOIDSize];
};

MONGO_CLIENT_API inline std::ostream& MONGO_CLIENT_FUNC operator<<(std::ostream& s, const OID& o) {
    return (s << o.toString());
}

MONGO_CLIENT_API inline StringBuilder& MONGO_CLIENT_FUNC
operator<<(StringBuilder& s, const OID& o) {
    return (s << o.toString());
}

enum JsonStringFormat {
    Strict,
    TenGen,
    JS
};

MONGO_CLIENT_API inline bool MONGO_CLIENT_FUNC operator==(const OID& lhs, const OID& rhs) {
    return lhs.compare(rhs) == 0;
}
MONGO_CLIENT_API inline bool MONGO_CLIENT_FUNC operator!=(const OID& lhs, const OID& rhs) {
    return lhs.compare(rhs) != 0;
}
MONGO_CLIENT_API inline bool MONGO_CLIENT_FUNC operator<(const OID& lhs, const OID& rhs) {
    return lhs.compare(rhs) < 0;
}
MONGO_CLIENT_API inline bool MONGO_CLIENT_FUNC operator<=(const OID& lhs, const OID& rhs) {
    return lhs.compare(rhs) <= 0;
}

}  // namespace mongo