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