namespace.h

Go to the documentation of this file.

#pragma once

#include <boost/filesystem/path.hpp>
#include <cstring>
#include <string>

#include "mongo/base/string_data.h"
#include "mongo/db/namespace_string.h"
#include "mongo/util/assert_util.h"
#include "mongo/util/mongoutils/str.h"

namespace mongo {

#pragma pack(1)

class Namespace {
public:
    Namespace(StringData ns) {
        *this = ns;
    }

    Namespace& operator=(StringData ns) {
        // We fill the remaining space with all zeroes here. As the full Namespace struct is in the
        // datafiles (the .ns files specifically), that is helpful as then they are deterministic in
        // the bytes they have for a given sequence of operations. This makes testing and debugging
        // the data files easier.
        //
        // If profiling indicates this method is a significant bottleneck, we could have a version
        // we use for reads which does not fill with zeroes, and keep the zeroing behavior on
        // writes.
        memset(buf, 0, sizeof(buf));
        uassert(10080,
                str::stream() << "ns name " << ns << " (size: " << ns.size()
                              << ") too long, max size is 127 bytes",
                ns.size() <= MaxNsLen);
        uassert(
            17380, "ns name can't contain embedded '\0' byte", ns.find('\0') == std::string::npos);
        ns.copyTo(buf, true);
        return *this;
    }

    void kill() {
        buf[0] = 0x7f;
    }

    bool operator==(const char* r) const {
        return strcmp(buf, r) == 0;
    }
    bool operator==(const Namespace& r) const {
        return strcmp(buf, r.buf) == 0;
    }
    bool operator!=(const char* r) const {
        return strcmp(buf, r) != 0;
    }
    bool operator!=(const Namespace& r) const {
        return strcmp(buf, r.buf) != 0;
    }

    bool hasDollarSign() const {
        return strchr(buf, '$') != NULL;
    }

    int hash() const {
        unsigned x = 0;
        const char* p = buf;
        while (*p) {
            x = x * 131 + *p;
            p++;
        }
        return (x & 0x7fffffff) | 0x8000000;  // must be > 0
    }

    size_t size() const {
        return strlen(buf);
    }

    std::string toString() const {
        return buf;
    }
    operator std::string() const {
        return buf;
    }

    std::string extraName(int i) const {
        char ex[] = "$extra";
        ex[5] += i;
        const std::string s = std::string(buf) + ex;
        massert(10348, "$extra: ns name too long", s.size() <= MaxNsLen);
        return s;
    }

    bool isExtra() const {
        const char* p = strstr(buf, "$extr");
        return p && p[5] &&
            p[6] == 0;  //== 0 is important in case an index uses name "$extra_1" for example
    }

    enum MaxNsLenValue {
        // Maximum possible length of name any namespace, including special ones like $extra. This
        // includes room for the NUL byte so it can be used when sizing buffers.
        MaxNsLenWithNUL = 128,

        // MaxNsLenWithNUL excluding the NUL byte. Use this when comparing std::string lengths.
        MaxNsLen = MaxNsLenWithNUL - 1,

        // Maximum allowed length of fully qualified namespace name of any real collection. Does not
        // include NUL so it can be directly compared to std::string lengths.
        MaxNsCollectionLen = MaxNsLen - 7 /*strlen(".$extra")*/,
    };

private:
    char buf[MaxNsLenWithNUL];
};
#pragma pack()

namespace {
MONGO_STATIC_ASSERT(sizeof(Namespace) == 128);
MONGO_STATIC_ASSERT(Namespace::MaxNsLenWithNUL == MaxDatabaseNameLen);
MONGO_STATIC_ASSERT((int)Namespace::MaxNsLenWithNUL == (int)NamespaceString::MaxNsLenWithNUL);
MONGO_STATIC_ASSERT((int)Namespace::MaxNsLen == (int)NamespaceString::MaxNsLen);
MONGO_STATIC_ASSERT((int)Namespace::MaxNsCollectionLen == (int)NamespaceString::MaxNsCollectionLen);
}  // namespace
}  // namespace mongo