key.h

Go to the documentation of this file.

// @file key.h class(es) representing individual keys in a btree

#pragma once

#include "mongo/db/jsobj.h"
#include "mongo/util/debug_util.h"

namespace mongo {

class KeyBson /* "KeyV0" */ {
public:
    KeyBson() {}
    explicit KeyBson(const char* keyData) : _o(keyData) {}
    explicit KeyBson(const BSONObj& obj) : _o(obj) {}
    int woCompare(const KeyBson& r, const Ordering& o) const;
    BSONObj toBson() const {
        return _o;
    }
    std::string toString() const {
        return _o.toString();
    }
    int dataSize() const {
        return _o.objsize();
    }
    const char* data() const {
        return _o.objdata();
    }
    BSONElement _firstElement() const {
        return _o.firstElement();
    }
    bool isCompactFormat() const {
        return false;
    }
    bool woEqual(const KeyBson& r) const;
    void assign(const KeyBson& rhs) {
        *this = rhs;
    }
    bool isValid() const {
        return true;
    }

private:
    BSONObj _o;
};

class KeyV1Owned;

// corresponding to BtreeData_V1
class KeyV1 {
    // disallowed just to make people be careful as we don't own the buffer
    void operator=(const KeyV1&);
    // disallowed as this is not a great idea as KeyV1Owned likely will go out of scope
    KeyV1(const KeyV1Owned&);

public:
    KeyV1() {
        _keyData = 0;
    }
    ~KeyV1() {
        DEV _keyData = (const unsigned char*)1;
    }

    KeyV1(const KeyV1& rhs) : _keyData(rhs._keyData) {
        dassert(_keyData > (const unsigned char*)1);
    }

    // explicit version of operator= to be safe
    void assign(const KeyV1& rhs) {
        _keyData = rhs._keyData;
    }

    explicit KeyV1(const char* keyData) : _keyData((unsigned char*)keyData) {}

    int woCompare(const KeyV1& r, const Ordering& o) const;
    bool woEqual(const KeyV1& r) const;
    BSONObj toBson() const;
    std::string toString() const {
        return toBson().toString();
    }

    const char* data() const {
        return (const char*)_keyData;
    }

    int dataSize() const;

    BSONElement _firstElement() const {
        return bson().firstElement();
    }
    bool isCompactFormat() const {
        return *_keyData != IsBSON;
    }

    bool isValid() const {
        return _keyData > (const unsigned char*)1;
    }

protected:
    enum { IsBSON = 0xff };
    const unsigned char* _keyData;
    BSONObj bson() const {
        dassert(!isCompactFormat());
        return BSONObj((const char*)_keyData + 1);
    }

private:
    int compareHybrid(const KeyV1& right, const Ordering& order) const;
};

class KeyV1Owned : public KeyV1 {
    void operator=(const KeyV1Owned&);

public:
    KeyV1Owned(const BSONObj& obj);

    KeyV1Owned(const KeyV1& rhs);

private:
    StackBufBuilder b;
    void traditional(const BSONObj& obj);  // store as traditional bson not as compact format
};
};