name.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2013 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/**************************************************************************************************/

#ifndef ADOBE_NAME_HPP
#define ADOBE_NAME_HPP

/**************************************************************************************************/

// stdc++
#include <functional>
#include <iosfwd>

// boost
#include <boost/operators.hpp>
#include <boost/type_traits/is_pod.hpp>

// asl
#include <adobe/conversion.hpp>
#include <adobe/cstring.hpp>
#include <adobe/fnv.hpp>

/**************************************************************************************************/

namespace adobe {

/**************************************************************************************************/

namespace detail {

/**************************************************************************************************/

constexpr std::size_t sizesz_k = sizeof(std::size_t);

constexpr bool sizeok_k = sizesz_k == 8 || sizesz_k == 4;

constexpr std::size_t name_fnv_prime_k =
    sizesz_k == 8 ? static_cast<std::size_t>(0x100000001b3) : static_cast<std::size_t>(0x1000193);

constexpr std::size_t name_fnv_basis_k = sizesz_k == 8
                                             ? static_cast<std::size_t>(0xcbf29ce484222325ULL)
                                             : static_cast<std::size_t>(0x811c9dc5);

constexpr std::size_t name_hash(const char* str, std::size_t len, std::size_t n,
                                std::size_t state) {
    static_assert(sizeok_k, "Unknown sizeof std::size_t (must be 4 or 8).");

    return n < len ? name_hash(str, len, n + 1,
                               (state xor static_cast<std::size_t>(str[n])) * name_fnv_prime_k)
                   : state;
}

constexpr std::size_t name_hash(const char* str, std::size_t len) {
    static_assert(sizeok_k, "Unknown sizeof std::size_t (must be 4 or 8).");

    return name_hash(str, len, 0, name_fnv_basis_k);
}

template <std::size_t N>
constexpr std::size_t name_hash(const char (&str)[N]) {
    static_assert(sizeok_k, "Unknown sizeof std::size_t (must be 4 or 8).");

    return name_hash(str, N - 1);
}

/**************************************************************************************************/

} // namespace detail

/**************************************************************************************************/

struct static_name_t;

/**************************************************************************************************/

namespace literals {

/**************************************************************************************************/

inline constexpr static_name_t operator"" _name(const char* str, std::size_t n);

/**************************************************************************************************/

} // namespace literals

/**************************************************************************************************/

using namespace literals;

/**************************************************************************************************/
struct static_name_t {
    explicit operator bool() const;

    friend bool operator==(const static_name_t& x, const static_name_t& y) {
        return x.hash_m == y.hash_m;
    }

    friend bool operator!=(const static_name_t& x, const static_name_t& y) { return !(x == y); }

    friend bool operator<(const static_name_t& x, const static_name_t& y);

private:
    static_name_t() = delete;

    constexpr static_name_t(const char* str, std::size_t hash) : string_m(str), hash_m(hash) {}

    friend struct name_t;

    friend constexpr static_name_t literals::operator"" _name(const char* str, std::size_t n);

    friend std::ostream& operator<<(std::ostream& s, const static_name_t& name);

    const char* string_m;

    std::size_t hash_m;
};

/**************************************************************************************************/

namespace literals {

/**************************************************************************************************/
inline constexpr static_name_t operator"" _name(const char* str, std::size_t n) {
    return static_name_t{str, detail::name_hash(str, n)};
}

/**************************************************************************************************/

} // namespace literals

/**************************************************************************************************/
struct name_t : boost::totally_ordered<name_t, name_t> {
    explicit name_t(const char* s = "") : ptr_m(map_string(s)) {}

    name_t(const static_name_t& static_name)
        : ptr_m(map_string(static_name.string_m, static_name.hash_m)) {}

    friend std::ostream& operator<<(std::ostream& s, const name_t& name);

    explicit operator bool() const;

    friend bool operator==(const name_t& x, const name_t& y) { return x.ptr_m == y.ptr_m; }

    friend bool operator<(const name_t& x, const name_t& y) {
        return std::strcmp(x.ptr_m, y.ptr_m) < 0;
    }

    const char* c_str() const { return ptr_m; }

    const char* begin() const { return ptr_m; }
    const char* end() const { return begin() + std::strlen(begin()); }

    static inline bool fast_sort(const name_t& x, const name_t& y) { return hash(x) < hash(y); }

private:
    friend struct std::hash<name_t>;

    static inline std::size_t hash(const name_t& x) {
        return reinterpret_cast<std::size_t>(x.ptr_m);
    }

    static const char* map_string(const char* str);
    static const char* map_string(const char* str, std::size_t hash);

    const char* ptr_m;
};

/**************************************************************************************************/
template <>
struct promote<static_name_t> {
    typedef name_t type;
};

/**************************************************************************************************/

} // namespace adobe

/**************************************************************************************************/

namespace std {

/**************************************************************************************************/
template <>
struct hash<adobe::name_t> {
public:
    inline std::size_t operator()(adobe::name_t const& name) const {
        return adobe::name_t::hash(name);
    }
};

template <>
struct hash<adobe::static_name_t> {
public:
    inline std::size_t operator()(adobe::static_name_t const& name) const {
        return std::hash<adobe::name_t>()(name);
    }
};

/**************************************************************************************************/

} // namespace std

/**************************************************************************************************/

namespace boost {

/**************************************************************************************************/

template <>
struct is_pod<adobe::name_t> : boost::mpl::true_ {};

/**************************************************************************************************/

} // namespace boost

/**************************************************************************************************/

#endif

/**************************************************************************************************/