Compiler Explorer

Source code

#include <cstdio>
#include <cstdint>
#include <cmath>
#include <cstring>
#include <string>
#include <string_view>
#include <array>
#include <span>
#include <vector>

// NOTE: I had to use std::string_view, so c++14 won't work here
// in godbolt but _should_ if using the OIIO string_view I think...

// See `main` at very bottom for the static_asserts

class ustring {
public:
    using rep_t      = const char*;  ///< The underlying representation type
    using value_type = char;
    using hash_t     = uint64_t;  ///< The hash type
    using pointer    = value_type*;
    using reference  = value_type&;
    using const_reference        = const value_type&;
    using size_type              = size_t;
    static const size_type npos  = static_cast<size_type>(-1);
    using const_iterator         = std::string::const_iterator;
    using const_reverse_iterator = std::string::const_reverse_iterator;

/// Default ctr for ustring -- make an empty string.
    constexpr ustring() noexcept
        : m_chars(nullptr)
    {
    }

/// Construct a ustring from a null-terminated C string (char *).
    explicit ustring(const char* str)
    {
        m_chars = str ? make_unique(str) : nullptr;
    }

/// Construct a ustring from a string_view, which can be auto-converted
    /// from either a null-terminated C string (char *) or a C++
    /// std::string.
    explicit ustring(std::string_view str)
    {
        m_chars = str.data() ? make_unique(str) : nullptr;
    }

/// Construct a ustring from at most n characters of str, starting at
    /// position pos.
    ustring(const char* str, size_type pos, size_type n)
        : m_chars(make_unique(std::string(str, pos, n).c_str()))
    {
    }

/// Construct a ustring from the first n characters of str.
    ustring(const char* str, size_type n)
        : m_chars(make_unique(std::string_view(str, n)))
    {
    }

/// Construct a ustring from n copies of character c.
    ustring(size_type n, char c)
        : m_chars(make_unique(std::string(n, c).c_str()))
    {
    }

/// Construct a ustring from an indexed substring of a std::string.
    ustring(const std::string& str, size_type pos, size_type n = npos)
    {
        std::string_view sref(str);
        sref    = sref.substr(pos, n);
        m_chars = make_unique(sref);
    }

/// Copy construct a ustring from another ustring.
    ustring(const ustring& str) noexcept = default;

/// Construct a ustring from an indexed substring of a ustring.
    ustring(const ustring& str, size_type pos, size_type n = npos)
    {
        std::string_view sref(str);
        sref    = sref.substr(pos, n);
        m_chars = make_unique(sref);
    }

/// ustring destructor.
    ~ustring() noexcept = default;

/// Conversion to an OIIO::string_view.
    operator std::string_view() const noexcept { return { c_str(), length() }; }

/// Conversion to std::string (explicit only!).
    explicit operator std::string() const noexcept { return string(); }

/// Assign a ustring to *this.
    const ustring& assign(const ustring& str)
    {
        m_chars = str.m_chars;
        return *this;
    }

/// Assign a substring of a ustring to *this.
    const ustring& assign(const ustring& str, size_type pos, size_type n = npos)
    {
        *this = ustring(str, pos, n);
        return *this;
    }

/// Assign a std::string to *this.
    const ustring& assign(const std::string& str)
    {
        assign(str.c_str());
        return *this;
    }

/// Assign a substring of a std::string to *this.
    const ustring& assign(const std::string& str, size_type pos,
                          size_type n = npos)
    {
        *this = ustring(str, pos, n);
        return *this;
    }

/// Assign a null-terminated C string (char*) to *this.
    const ustring& assign(const char* str)
    {
        m_chars = str ? make_unique(str) : nullptr;
        return *this;
    }

/// Assign the first n characters of str to *this.
    const ustring& assign(const char* str, size_type n)
    {
        *this = ustring(str, n);
        return *this;
    }

/// Assign n copies of c to *this.
    const ustring& assign(size_type n, char c)
    {
        *this = ustring(n, c);
        return *this;
    }

/// Assign a string_view to *this.
    const ustring& assign(std::string_view str)
    {
        m_chars = str.length() ? make_unique(str) : nullptr;
        return *this;
    }

/// Assign a ustring to another ustring.
    constexpr ustring& operator=(const ustring& str) = default; // { return assign(str); }

/// Assign a null-terminated C string (char *) to a ustring.
    const ustring& operator=(const char* str) { return assign(str); }

/// Assign a C++ std::string to a ustring.
    const ustring& operator=(const std::string& str) { return assign(str); }

/// Assign a string_view to a ustring.
    const ustring& operator=(std::string_view str) { return assign(str); }

/// Assign a single char to a ustring.
    const ustring& operator=(char c)
    {
        return *this = ustring(std::string_view(&c, 1));
    }

/// Return a C string representation of a ustring.
    const char* c_str() const noexcept { return m_chars; }

/// Return a C string representation of a ustring.
    const char* data() const noexcept { return c_str(); }

/// Return a C++ std::string representation of a ustring.
    const std::string& string() const noexcept
    {
        if (m_chars) {
            const TableRep* rep = (const TableRep*)m_chars - 1;
            return rep->str;
        } else
            return empty_std_string;
    }

/// Reset to an empty string.
    void clear() noexcept { m_chars = nullptr; }

/// Return the number of characters in the string.
    size_t length() const noexcept
    {
        if (!m_chars)
            return 0;
        const TableRep* rep = ((const TableRep*)m_chars) - 1;
        return rep->length;
    }

/// Return a hashed version of the string
    hash_t hash() const noexcept
    {
        if (!m_chars)
            return 0;
        const TableRep* rep = ((const TableRep*)m_chars) - 1;
        return rep->hashed;
    }

/// Return the number of characters in the string.
    size_t size() const noexcept { return length(); }

/// Is the string empty -- i.e., is it nullptr or does it point to an
    /// empty string?
    bool empty() const noexcept { return (size() == 0); }

/// Return a const_iterator that references the first character of
    /// the string.
    const_iterator begin() const noexcept { return string().begin(); }

/// Return a const_iterator that references the end of a traversal
    /// of the characters of the string.
    const_iterator end() const noexcept { return string().end(); }

/// Return a const_reverse_iterator that references the last
    /// character of the string.
    const_reverse_iterator rbegin() const noexcept { return string().rbegin(); }

/// Return a const_reverse_iterator that references the end of
    /// a reverse traversal of the characters of the string.
    const_reverse_iterator rend() const noexcept { return string().rend(); }

/// Return a reference to the character at the given position.
    /// Note that it's up to the caller to be sure pos is within the
    /// size of the string.
    const_reference operator[](size_type pos) const noexcept
    {
        return c_str()[pos];
    }

/// Dump into character array s the characters of this ustring,
    /// beginning with position pos and copying at most n characters.
    size_type copy(char* s, size_type n, size_type pos = 0) const
    {
        if (m_chars == nullptr) {
            s[0] = 0;
            return 0;
        }
        char* c = ::strncpy(s, c_str() + pos, n);  // NOSONAR
        return (size_type)(c - s);
    }

/// Returns a substring of the ustring object consisting of n
    /// characters starting at position pos.
    ustring substr(size_type pos = 0, size_type n = npos) const
    {
        return ustring(*this, pos, n);
    }

size_type find(const ustring& str, size_type pos = 0) const noexcept
    {
        return string().find(str.string(), pos);
    }

size_type find(const std::string& str, size_type pos = 0) const noexcept
    {
        return string().find(str, pos);
    }

size_type find(const char* s, size_type pos, size_type n) const
    {
        return string().find(s, pos, n);
    }

size_type find(const char* s, size_type pos = 0) const
    {
        return string().find(s, pos);
    }

size_type find(char c, size_type pos = 0) const noexcept
    {
        return string().find(c, pos);
    }

size_type rfind(const ustring& str, size_type pos = npos) const noexcept
    {
        return string().rfind(str.string(), pos);
    }

size_type rfind(const std::string& str, size_type pos = npos) const noexcept
    {
        return string().rfind(str, pos);
    }

size_type rfind(const char* s, size_type pos, size_type n) const
    {
        return string().rfind(s, pos, n);
    }

size_type rfind(const char* s, size_type pos = npos) const
    {
        return string().rfind(s, pos);
    }

size_type rfind(char c, size_type pos = npos) const noexcept
    {
        return string().rfind(c, pos);
    }

size_type find_first_of(const ustring& str,
                            size_type pos = 0) const noexcept
    {
        return string().find_first_of(str.string(), pos);
    }

size_type find_first_of(const std::string& str,
                            size_type pos = 0) const noexcept
    {
        return string().find_first_of(str, pos);
    }

size_type find_first_of(const char* s, size_type pos, size_type n) const
    {
        return string().find_first_of(s, pos, n);
    }

size_type find_first_of(const char* s, size_type pos = 0) const
    {
        return string().find_first_of(s, pos);
    }

size_type find_first_of(char c, size_type pos = 0) const noexcept
    {
        return string().find_first_of(c, pos);
    }

size_type find_last_of(const ustring& str,
                           size_type pos = npos) const noexcept
    {
        return string().find_last_of(str.string(), pos);
    }

size_type find_last_of(const std::string& str,
                           size_type pos = npos) const noexcept
    {
        return string().find_last_of(str, pos);
    }

size_type find_last_of(const char* s, size_type pos, size_type n) const
    {
        return string().find_last_of(s, pos, n);
    }

size_type find_last_of(const char* s, size_type pos = npos) const
    {
        return string().find_last_of(s, pos);
    }

size_type find_last_of(char c, size_type pos = npos) const noexcept
    {
        return string().find_last_of(c, pos);
    }

size_type find_first_not_of(const ustring& str,
                                size_type pos = 0) const noexcept
    {
        return string().find_first_not_of(str.string(), pos);
    }

size_type find_first_not_of(const std::string& str,
                                size_type pos = 0) const noexcept
    {
        return string().find_first_not_of(str, pos);
    }

size_type find_first_not_of(const char* s, size_type pos, size_type n) const
    {
        return string().find_first_not_of(s, pos, n);
    }

size_type find_first_not_of(const char* s, size_type pos = 0) const
    {
        return string().find_first_not_of(s, pos);
    }

size_type find_first_not_of(char c, size_type pos = 0) const noexcept
    {
        return string().find_first_not_of(c, pos);
    }

size_type find_last_not_of(const ustring& str,
                               size_type pos = npos) const noexcept
    {
        return string().find_last_not_of(str.string(), pos);
    }

size_type find_last_not_of(const std::string& str,
                               size_type pos = npos) const noexcept
    {
        return string().find_last_not_of(str, pos);
    }

size_type find_last_not_of(const char* s, size_type pos, size_type n) const
    {
        return string().find_last_not_of(s, pos, n);
    }

size_type find_last_not_of(const char* s, size_type pos = npos) const
    {
        return string().find_last_not_of(s, pos);
    }

size_type find_last_not_of(char c, size_type pos = npos) const noexcept
    {
        return string().find_last_not_of(c, pos);
    }

/// Return 0 if *this is lexicographically equal to str, -1 if
    /// *this is lexicographically earlier than str, 1 if *this is
    /// lexicographically after str.
    int compare(std::string_view str) const noexcept
    {
        return std::string_view(*this).compare(str);
    }

/// Return 0 if *this is lexicographically equal to str, -1 if
    /// *this is lexicographically earlier than str, 1 if *this is
    /// lexicographically after str.
    int compare(const char* str) const noexcept
    {
        return ::strcmp(c_str() ? c_str() : "", str ? str : "");
    }

/// Return 0 if a is lexicographically equal to b, -1 if a is
    /// lexicographically earlier than b, 1 if a is lexicographically
    /// after b.
    friend int compare(const std::string& a, const ustring& b) noexcept
    {
        return std::string_view(a).compare(b);
    }

/// Test two ustrings for equality -- are they comprised of the same
    /// sequence of characters.  Note that because ustrings are unique,
    /// this is a trivial pointer comparison, not a char-by-char loop as
    /// would be the case with a char* or a std::string.
    bool operator==(const ustring& str) const noexcept
    {
        return c_str() == str.c_str();
    }

/// Test two ustrings for inequality -- are they comprised of different
    /// sequences of characters.  Note that because ustrings are unique,
    /// this is a trivial pointer comparison, not a char-by-char loop as
    /// would be the case with a char* or a std::string.
    bool operator!=(const ustring& str) const noexcept
    {
        return c_str() != str.c_str();
    }

/// Test a ustring (*this) for lexicographic equality with std::string
    /// x.
    bool operator==(const std::string& x) const noexcept
    {
        return compare(x) == 0;
    }

/// Test a ustring (*this) for lexicographic equality with string_view
    /// x.
    bool operator==(std::string_view x) const noexcept { return compare(x) == 0; }

/// Test a ustring (*this) for lexicographic equality with char* x.
    bool operator==(const char* x) const noexcept { return compare(x) == 0; }

/// Test for lexicographic equality between std::string a and ustring
    /// b.
    friend bool operator==(const std::string& a, const ustring& b) noexcept
    {
        return b.compare(a) == 0;
    }

/// Test for lexicographic equality between string_view a and ustring
    /// b.
    friend bool operator==(std::string_view a, const ustring& b) noexcept
    {
        return b.compare(a) == 0;
    }

/// Test for lexicographic equality between char* a and ustring
    /// b.
    friend bool operator==(const char* a, const ustring& b) noexcept
    {
        return b.compare(a) == 0;
    }

/// Test a ustring (*this) for lexicographic inequality with
    /// std::string x.
    bool operator!=(const std::string& x) const noexcept
    {
        return compare(x) != 0;
    }

/// Test a ustring (*this) for lexicographic inequality with
    /// string_view x.
    bool operator!=(std::string_view x) const noexcept { return compare(x) != 0; }

/// Test a ustring (*this) for lexicographic inequality with
    /// char* x.
    bool operator!=(const char* x) const noexcept { return compare(x) != 0; }

/// Test for lexicographic inequality between std::string a and
    /// ustring b.
    friend bool operator!=(const std::string& a, const ustring& b) noexcept
    {
        return b.compare(a) != 0;
    }

/// Test for lexicographic inequality between string_view a and
    /// ustring b.
    friend bool operator!=(std::string_view a, const ustring& b) noexcept
    {
        return b.compare(a) != 0;
    }

/// Test for lexicographic inequality between char* a and
    /// ustring b.
    friend bool operator!=(const char* a, const ustring& b) noexcept
    {
        return b.compare(a) != 0;
    }

/// Test for lexicographic 'less', comes in handy for lots of STL
    /// containers and algorithms.
    bool operator<(const ustring& x) const noexcept { return compare(x) < 0; }

/// Return the statistics output as a string.
    static std::string getstats(bool verbose = true);

/// Return the amount of memory consumed by the ustring table.
    static size_t memory();

/// Return the total number of ustrings in the internal table.
    static size_t total_ustrings();

/// Return the total number ustrings that have the exact hash as another
    /// ustring. If `collisions` is passed, store all the colliding ustrings
    /// in the vector.
    static size_t hash_collisions(std::vector<ustring>* collisions = nullptr);

/// Given a string_view, return a pointer to the unique
    /// version kept in the internal table (creating a new table entry
    /// if we haven't seen this sequence of characters before).
    /// N.B.: this is equivalent to ustring(str).c_str().  It's also the
    /// routine that is used directly by ustring's internals to generate
    /// the canonical unique copy of the characters.
    static const char* make_unique(std::string_view str);
private:
    // Individual ustring internal representation -- the unique characters.
    //
    rep_t m_chars;

public:
    // Representation within the hidden string table -- DON'T EVER CREATE
    // ONE OF THESE YOURSELF!
    // The characters are found directly after the rep.  So that means that
    // if you know the rep, the chars are at (char *)(rep+1), and if you
    // know the chars, the rep is at ((TableRep *)chars - 1).
    struct TableRep {
        hash_t hashed;    // precomputed Hash value
        std::string str;  // String representation
        size_t length;    // Length of the string; must be right before cap
        size_t dummy_capacity;  // Dummy field! must be right before refcount
        int dummy_refcount;     // Dummy field! must be right before chars
        TableRep(std::string_view strref, hash_t hash);
        ~TableRep();
        const char* c_str() const noexcept { return (const char*)(this + 1); }
    };

private:
    static std::string empty_std_string;
};

int main()
{
  static_assert(std::is_default_constructible<ustring>::value == true);
  static_assert(std::is_trivially_copyable<ustring>::value == true);
  static_assert(std::is_trivially_destructible<ustring>::value == true);
  static_assert(std::is_trivially_move_constructible<ustring>::value == true);
  static_assert(std::is_trivially_copy_constructible<ustring>::value == true);
  static_assert(std::is_trivially_move_assignable<ustring>::value == true);

// weird
  static_assert(std::is_trivially_default_constructible<ustring>::value == false);
}