name.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2013 Adobe Systems Incorporated
    Distributed under the Boost Software License - Version 1.0 (see the accompanying file LICENSE
    or a copy at https://stlab.github.io/adobe_source_libraries/licenses.html)
*/
 
/**************************************************************************************************/
 
#ifndef ADOBE_NAME_HPP
#define ADOBE_NAME_HPP
 
/**************************************************************************************************/
 
// stdc++
#include <cstring>
#include <functional>
#include <iosfwd>
#include <string_view>
 
// boost
#include <boost/mpl/bool.hpp>
#include <boost/operators.hpp>
 
// asl
#include <adobe/conversion.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 ^ 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);

    std::size_t hash() const { return hash_m; }
 
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> {
    using const_iterator = const char*;
    using iterator = const char*;
 
    explicit name_t(const char* s = "") : ptr_m(map_string(s)) {}
    operator std::string_view() const { return ptr_m; }

    name_t(const static_name_t& static_name)
        : ptr_m(map_string(static_name.string_m, static_name.hash_m, true)) {}
 
    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()); }

    struct fast_compare {
        bool operator()(const name_t& x, const name_t& y) const { return x.ptr_m < y.ptr_m; }
    };

    [[deprecated("use `fast_compare{}` instead")]] 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 std::hash<const char*>{}(x.ptr_m); }
 
    static const char* map_string(const char* str);
    static const char* map_string(const char* str, std::size_t hash, bool is_static);
 
    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
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/