namespace_string.h

// @file namespacestring.h

/*    Copyright 2014 MongoDB 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 <algorithm>
#include <string>

#include "mongo/base/string_data.h"
#include "mongo/util/assert_util.h"

namespace mongo {

/* in the mongo source code, "client" means "database". */

const size_t MaxDatabaseNameLen = 128;  // max str len for the db name, including null char

bool legalClientSystemNS(const StringData& ns, bool write);

/* e.g.
   NamespaceString ns("acme.orders");
   cout << ns.coll; // "orders"
*/
class NamespaceString {
public:
    NamespaceString();

    explicit NamespaceString(const StringData& ns);

    NamespaceString(const StringData& dbName, const StringData& collectionName);

    enum MaxNsLenValue {
        // Maximum possible length of name any namespace, including special ones like $extra.
        // This includes rum 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")*/,
    };

    StringData db() const;
    StringData coll() const;

    const std::string& ns() const {
        return _ns;
    }

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

    size_t size() const {
        return _ns.size();
    }

    bool isSystem() const {
        return coll().startsWith("system.");
    }
    bool isSystemDotIndexes() const {
        return coll() == "system.indexes";
    }
    bool isConfigDB() const {
        return db() == "config";
    }
    bool isCommand() const {
        return coll() == "$cmd";
    }
    bool isOplog() const {
        return oplog(_ns);
    }
    bool isSpecialCommand() const {
        return coll().startsWith("$cmd.sys");
    }
    bool isSpecial() const {
        return special(_ns);
    }
    bool isNormal() const {
        return normal(_ns);
    }
    bool isListCollectionsGetMore() const;
    bool isListIndexesGetMore() const;

    NamespaceString getTargetNSForListIndexesGetMore() const;

    bool isValid() const {
        return validDBName(db()) && !coll().empty();
    }

    bool operator==(const std::string& nsIn) const {
        return nsIn == _ns;
    }
    bool operator==(const StringData& nsIn) const {
        return nsIn == _ns;
    }
    bool operator==(const NamespaceString& nsIn) const {
        return nsIn._ns == _ns;
    }

    bool operator!=(const std::string& nsIn) const {
        return nsIn != _ns;
    }
    bool operator!=(const NamespaceString& nsIn) const {
        return nsIn._ns != _ns;
    }

    bool operator<(const NamespaceString& rhs) const {
        return _ns < rhs._ns;
    }

    std::string getSisterNS(const StringData& local) const;

    // @return db() + ".system.indexes"
    std::string getSystemIndexesCollection() const;

    // @return db() + ".$cmd"
    std::string getCommandNS() const;

    static bool normal(const StringData& ns);

    static bool oplog(const StringData& ns);

    static bool special(const StringData& ns);

    static bool validDBName(const StringData& dbin);

    static bool validCollectionComponent(const StringData& ns);

    static bool validCollectionName(const StringData& coll);

private:
    std::string _ns;
    size_t _dotIndex;
};


// "database.a.b.c" -> "database"
inline StringData nsToDatabaseSubstring(const StringData& ns) {
    size_t i = ns.find('.');
    if (i == std::string::npos) {
        massert(10078, "nsToDatabase: db too long", ns.size() < MaxDatabaseNameLen);
        return ns;
    }
    massert(10088, "nsToDatabase: db too long", i < static_cast<size_t>(MaxDatabaseNameLen));
    return ns.substr(0, i);
}

// "database.a.b.c" -> "database"
inline void nsToDatabase(const StringData& ns, char* database) {
    StringData db = nsToDatabaseSubstring(ns);
    db.copyTo(database, true);
}

// TODO: make this return a StringData
inline std::string nsToDatabase(const StringData& ns) {
    return nsToDatabaseSubstring(ns).toString();
}

// "database.a.b.c" -> "a.b.c"
inline StringData nsToCollectionSubstring(const StringData& ns) {
    size_t i = ns.find('.');
    massert(16886, "nsToCollectionSubstring: no .", i != std::string::npos);
    return ns.substr(i + 1);
}

inline bool nsIsFull(const StringData& ns) {
    size_t i = ns.find('.');
    if (i == std::string::npos)
        return false;
    if (i == ns.size() - 1)
        return false;
    return true;
}

inline bool nsIsDbOnly(const StringData& ns) {
    size_t i = ns.find('.');
    if (i == std::string::npos)
        return true;
    return false;
}

int nsDBHash(const std::string& ns);

bool nsDBEquals(const std::string& a, const std::string& b);

struct NamespaceDBHash {
    int operator()(const std::string& ns) const {
        return nsDBHash(ns);
    }
};

struct NamespaceDBEquals {
    bool operator()(const std::string& a, const std::string& b) const {
        return nsDBEquals(a, b);
    }
};
}


#include "mongo/db/namespace_string-inl.h"