StringView.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
 
//+
 
 
#ifndef AMINO_CORE_STRING_VIEW_H
#define AMINO_CORE_STRING_VIEW_H
 
#include "internal/ConfigMacros.h"
 
#include <cassert>
#include <cstddef>
#include <string_view>
#include <utility>
#ifndef AMINO_REMOVE_TRANSITIVE_HEADERS
#include <string>
#endif
 
//==============================================================================
// NAMESPACE Amino
//==============================================================================
 
namespace Amino {
 
//==============================================================================
// CLASS StringView
//==============================================================================
 
class StringView {
private:
    template <typename R>
    static inline constexpr bool is_raw_cstring =
        (std::is_same_v<std::decay_t<R>, char const*> ||
         std::is_same_v<std::decay_t<R>, char*>)&& //
        !std::is_array_v<std::remove_reference_t<R>>;
 
    template <typename R>
    static inline constexpr bool is_sview_convertible_v =
        !is_raw_cstring<R> && std::is_convertible_v<R, std::string_view>;
 
    template <typename R>
    static inline constexpr bool is_sview_constructible_v =
        !is_sview_convertible_v<R> &&
        std::is_constructible_v<std::string_view, R>;
 
    // Allow StringView to be implicitly constructed from any type that is
    // implicitly convertible to std::string_view (except char const* is made
    // explicit).
    template <typename R>
    using enable_if_implicitly_constructible =
        std::enable_if_t<is_sview_convertible_v<R>>;
 
    template <typename R>
    using enable_if_explicitly_constructible =
        std::enable_if_t<is_sview_constructible_v<R>>;
 
public:
    /*----- member functions -----*/
 
    constexpr StringView() noexcept = default;
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    StringView(std::nullptr_t) = delete;
 
    constexpr StringView(char const* data, size_t size) noexcept
        : m_data(data), m_size(size) {}
 
    template <typename R, enable_if_explicitly_constructible<R>* = nullptr>
    AMINO_INTERNAL_FORCEINLINE constexpr explicit StringView(R&& r)
        : StringView(Private{}, std::string_view{std::forward<R>(r)}) {}
 
    template <typename R, enable_if_implicitly_constructible<R>* = nullptr>
    // NOLINTNEXTLINE(google-explicit-constructor)
    AMINO_INTERNAL_FORCEINLINE constexpr /*implicit*/ StringView(R&& r)
        : StringView(Private{}, std::forward<R>(r)) {}
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    AMINO_INTERNAL_FORCEINLINE constexpr operator std::string_view()
        const noexcept {
        return {data(), size()}; // LCOV_EXCL_BR_LINE
    }
 
    constexpr char const* data() const noexcept { return m_data; }
 
    constexpr size_t size() const noexcept { return m_size; }
 
    constexpr size_t length() const noexcept { return size(); }
 
    constexpr bool empty() const noexcept { return m_size == 0; }
 
    constexpr char const* cbegin() const noexcept { return m_data; }
    constexpr char const* begin() const noexcept { return cbegin(); }
 
    constexpr char const* cend() const noexcept { return m_data + m_size; }
    constexpr char const* end() const noexcept { return cend(); }
 
    constexpr char front() const noexcept { return deref(0); }
 
    constexpr char back() const noexcept { return deref(m_size - 1); }
 
    constexpr char operator[](size_t idx) const noexcept { return deref(idx); }
 
    constexpr bool operator==(StringView o) const noexcept {
        return size() == o.size() && compare(o) == 0;
    }
    constexpr bool operator<(StringView o) const noexcept {
        return compare(o) < 0;
    }
    constexpr bool operator>(StringView o) const noexcept {
        return compare(o) > 0;
    }
    constexpr bool operator!=(StringView o) const noexcept {
        return !(*this == o);
    }
    constexpr bool operator<=(StringView o) const noexcept {
        return !(*this > o);
    }
    constexpr bool operator>=(StringView o) const noexcept {
        return !(*this < o);
    }
 
private:
    struct Private {};
 
    /*----- member functions -----*/
 
    AMINO_INTERNAL_FORCEINLINE constexpr StringView(
        Private, std::string_view s) noexcept
        : StringView(s.data(), s.size()) {}
 
    constexpr char deref(size_t idx) const noexcept {
        assert(m_data);
        assert(!empty());
        assert(idx < m_size);
        return m_data[idx];
    }
 
    constexpr int compare(StringView o) const noexcept {
        size_t size = m_size < o.m_size ? m_size : o.m_size;
        for (size_t i = 0; i < size; ++i) {
            if (m_data[i] < o.m_data[i]) return -1;
            if (m_data[i] > o.m_data[i]) return +1;
        }
        if (m_size < o.m_size) return -1;
        if (m_size > o.m_size) return +1;
        return 0;
    }
 
    /*----- data members -----*/
 
    char const* m_data = nullptr;
 
    size_t m_size = 0;
};
 
//==============================================================================
// CLASS StringLiteral
//==============================================================================
 
class StringLiteral;
 
namespace StringViewLiterals {
constexpr StringLiteral operator""_asv(char const* data, size_t size);
} // namespace StringViewLiterals
 
class StringLiteral final : public StringView {
private:
    friend constexpr StringLiteral StringViewLiterals::operator""_asv(
        char const*, size_t);
    constexpr StringLiteral(char const* name, size_t size)
        : StringView{name, size} {}
};
 
//==============================================================================
// NAMESPACE StringViewLiterals
//==============================================================================
 
namespace StringViewLiterals {
 
constexpr StringLiteral operator""_asv(char const* data, size_t size) {
    return StringLiteral{data, size};
}
 
} // namespace StringViewLiterals
 
} // namespace Amino
 
#endif