String.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_H
#define AMINO_CORE_STRING_H
 
#include "CoreExport.h"
 
#include <Amino/Core/Span.h>
#include <Amino/Core/StringView.h>
 
#include "internal/ConfigMacros.h"
#include "internal/Storage.h"
#include "internal/TypeTraits.h"
 
#include <cstddef>
#include <string_view>
 
namespace Amino {
struct SdkStorage;
 
//-----------------------------------------------------------------------------
// Class String
//-----------------------------------------------------------------------------
 
class AMINO_CORE_SHARED_DECL String {
private:
    template <typename T>
    using is_string_view_like = std::is_convertible<T const&, StringView>;
    template <typename T, typename R = void>
    using enable_if_string_view_like =
        std::enable_if_t<is_string_view_like<T>::value, R>;
 
public:
    /*----- types -----*/
 
    using value_type      = char;
    using iterator        = value_type*;
    using const_iterator  = const value_type*;
    using size_type       = std::size_t;
    using difference_type = std::ptrdiff_t;
 
    /*----- member functions -----*/
 
    String();
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    String(std::nullptr_t) = delete;
 
    String(const String& str);
 
    String(String&& str) noexcept;
 
    String(const String& str, size_type pos, size_type len = npos);
 
    String(const char* s); // NOLINT: implicit conversion allowed!
 
    String(const char* s, size_type n);
 
    explicit String(StringView sv) : String(sv.data(), sv.size()) {}
 
    String(size_type n, char c);
 
    ~String();
 
    String& operator=(const String& s);
    String& operator=(String&& s) noexcept;
    String& operator=(const char* s);
    String& operator=(char s);
 
    template <
        typename StringViewLike,
        typename = enable_if_string_view_like<StringViewLike>>
    AMINO_INTERNAL_FORCEINLINE String& operator=(StringViewLike const& s) {
        internal_assign(s);
        return *this;
    }
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    AMINO_INTERNAL_FORCEINLINE operator std::string_view() const {
        return {internal_string_view()}; // LCOV_EXCL_BR_LINE
    }
 
    String& append(const String& s);
    String& append(String&& s);
    String& append(const char* s);
 
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, String&>
        append(StringViewLike const& s) {
        internal_append(s);
        return *this;
    }
 
    String& append(const char* s, size_type n);
 
    String& append(const String& str, size_type subpos, size_type sublen);
 
    String& append(size_type n, char c);
 
    String& assign(const String& s) { return *this = s; }
    String& assign(String&& s) noexcept { return *this = std::move(s); }
    String& assign(const char* s) { return *this = s; }
 
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, String&>
        assign(StringViewLike const& s) {
        internal_assign(s);
        return *this;
    }
 
    String& assign(const char* s, size_type n);
 
    String& assign(const String& str, size_type subpos, size_type sublen);
 
    String& assign(size_type n, char c);
 
    char& at(size_type pos);
 
    const char& at(size_type pos) const;
 
    char& back();
 
    const char& back() const;
 
    size_type capacity() const;
 
    void clear();
 
    int compare(const String& s) const;
    int compare(const char* s) const;
 
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, int>
        compare(StringViewLike const& s) const {
        return internal_compare(s);
    }
 
    int compare(size_type pos, size_type len, const String& str) const;
 
    int compare(
        size_type     pos,
        size_type     len,
        const String& str,
        size_type     subpos,
        size_type     sublen) const;
 
    int compare(size_type pos, size_type len, const char* s) const;
 
    int compare(size_type pos, size_type len, const char* s, size_type n) const;
 
    size_type copy(char* s, size_type len, size_type pos = 0) const;
 
    const char* c_str() const;
 
    const char* data() const;
 
    bool empty() const;
 
    String& erase(size_type pos = 0, size_type len = npos);
 
    size_type find(const String& str, size_type pos = 0) const;
    size_type find(const char* s, size_type pos = 0) const;
    size_type find(const char* s, size_type pos, size_type n) const;
    size_type find(char c, size_type pos = 0) const;
 
    size_type find_first_not_of(const String& str, size_type pos = 0) const;
    size_type find_first_not_of(const char* s, size_type pos = 0) const;
    size_type find_first_not_of(
        const char* s, size_type pos, size_type n) const;
    size_type find_first_not_of(char c, size_type pos = 0) const;
 
    size_type find_first_of(const String& str, size_type pos = 0) const;
    size_type find_first_of(const char* s, size_type pos = 0) const;
    size_type find_first_of(const char* s, size_type pos, size_type n) const;
    size_type find_first_of(char c, size_type pos = 0) const;
 
    size_type find_last_not_of(const String& str, size_type pos = npos) const;
    size_type find_last_not_of(const char* s, size_type pos = npos) const;
    size_type find_last_not_of(const char* s, size_type pos, size_type n) const;
    size_type find_last_not_of(char c, size_type pos = npos) const;
 
    size_type find_last_of(const String& str, size_type pos = npos) const;
    size_type find_last_of(const char* s, size_type pos = npos) const;
    size_type find_last_of(const char* s, size_type pos, size_type n) const;
    size_type find_last_of(char c, size_type pos = npos) const;
 
    iterator       begin();
    const_iterator begin() const { return cbegin(); }
    const_iterator cbegin() const;
 
    iterator       end();
    const_iterator end() const { return cend(); }
    const_iterator cend() const;
 
    char&       front();
    const char& front() const;
 
    String& insert(size_type pos, const String& str);
    String& insert(
        size_type pos, const String& str, size_type subpos, size_type sublen);
    String& insert(size_type pos, const char* s);
    String& insert(size_type pos, const char* s, size_type n);
    String& insert(size_type pos, size_type n, char c);
 
    size_type length() const;
 
    size_type max_size() const;
 
    String& operator+=(const String& s) { return append(s); }
    String& operator+=(const char* s) { return append(s); }
    String& operator+=(char s) {
        push_back(s);
        return *this;
    }
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, String&>
        operator+=(StringViewLike const& s) {
        return internal_append(s);
    }
 
    char& operator[](size_type pos);
 
    const char& operator[](size_type pos) const;
 
    void pop_back();
 
    void push_back(char c);
 
    String& replace(size_type pos, size_type len, const String& str);
    String& replace(
        size_type     pos,
        size_type     len,
        const String& str,
        size_type     subpos,
        size_type     sublen);
    String& replace(size_type pos, size_type len, const char* s);
    String& replace(size_type pos, size_type len, const char* s, size_type n);
    String& replace(size_type pos, size_type len, size_type n, char c);
 
    void reserve(size_type n = 0);
 
    void resize(size_type n);
 
    void resize(size_type n, char c);
 
    size_type rfind(const String& str, size_type pos = npos) const;
    size_type rfind(const char* s, size_type pos = npos) const;
    size_type rfind(const char* s, size_type pos, size_type n) const;
    size_type rfind(char c, size_type pos = npos) const;
 
    void shrink_to_fit();
 
    size_type size() const;
 
    String substr(size_type pos = 0, size_type len = npos) const;
 
    void swap(String& str);
 
    bool operator==(const String& rhs) const;
    bool operator==(char const* rhs) const;
 
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, bool>
        operator==(StringViewLike const& rhs) const {
        return internal_equals(rhs);
    }
 
    bool operator!=(const String& rhs) const { return !(*this == rhs); }
    bool operator!=(char const* rhs) const { return !(*this == rhs); }
 
    template <typename StringViewLike>
    AMINO_INTERNAL_FORCEINLINE //
        enable_if_string_view_like<StringViewLike, bool>
        operator!=(StringViewLike const& rhs) const {
        return !internal_equals(rhs);
    }
 
    template <typename T>
    AMINO_INTERNAL_FORCEINLINE auto operator<(T const& rhs) const
        -> decltype(compare(rhs) < 0) {
        return compare(rhs) < 0;
    }
    template <typename T>
    AMINO_INTERNAL_FORCEINLINE auto operator>(T const& rhs) const
        -> decltype(compare(rhs) > 0) {
        return compare(rhs) > 0;
    }
    template <typename T>
    AMINO_INTERNAL_FORCEINLINE auto operator<=(T const& rhs) const
        -> decltype(compare(rhs) <= 0) {
        return compare(rhs) <= 0;
    }
    template <typename T>
    AMINO_INTERNAL_FORCEINLINE auto operator>=(T const& rhs) const
        -> decltype(compare(rhs) >= 0) {
        return compare(rhs) >= 0;
    }
 
    const char* asChar() const;
 
    AMINO_INTERNAL_FORCEINLINE static String concat() { return String{}; }
 
    template <typename S>
    AMINO_INTERNAL_FORCEINLINE static std::
        enable_if_t<std::is_constructible_v<String, S>, String>
        concat(S&& s) {
        return String{std::forward<S>(s)};
    }
    template <typename S1, typename S2, typename... S>
    AMINO_INTERNAL_FORCEINLINE static String concat(
        S1 const& s1, S2 const& s2, S&&... s) {
        constexpr auto N = 2 + sizeof...(s);
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        StringView const msgs[N] = {s1, s2, s...};
        return concat(SpanParam<StringView const>{msgs, N});
    }
    static String concat(SpanParam<StringView const> const& strs);
 
public:
    static constexpr size_type npos = ~size_type(0);
 
private:
    StringView internal_string_view() const;
 
    String& internal_append(StringView s);
 
    String& internal_assign(StringView s);
 
    bool internal_equals(StringView s) const;
 
    int internal_compare(StringView s) const;
 
    friend SdkStorage;
    Internal::Storage_t<2> m_storage{};
};
 
//
// Non-member functions
//
 
AMINO_CORE_SHARED_DECL String operator+(const String& lhs, const String& rhs);
AMINO_CORE_SHARED_DECL String operator+(const String& lhs, const char* rhs);
AMINO_CORE_SHARED_DECL String operator+(const char* lhs, const String& rhs);
AMINO_CORE_SHARED_DECL String operator+(const String& lhs, char rhs);
AMINO_CORE_SHARED_DECL String operator+(char lhs, const String& rhs);
 
namespace Internal {
template <typename T>
using is_amino_string = std::
    is_same<std::remove_cv_t<std::remove_reference_t<std::decay_t<T>>>, String>;
template <typename LHS, typename RHS>
using enable_if_rhs_compare = std::enable_if_t<
    !is_amino_string<LHS>::value && is_amino_string<RHS>::value,
    bool>;
} // namespace Internal
 
// String on the right hand side
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator==(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator==(lhs);
}
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator!=(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator!=(lhs);
}
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator<(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator>(lhs);
}
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator>(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator<(lhs);
}
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator<=(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator>=(lhs);
}
template <typename LHS, typename RHS>
AMINO_INTERNAL_FORCEINLINE Internal::enable_if_rhs_compare<LHS, RHS> operator>=(
    LHS const& lhs, RHS&& rhs) {
    return rhs.operator<=(lhs);
}
 
AMINO_CORE_SHARED_DECL void swap(String& x, String& y);
 
AMINO_CORE_SHARED_DECL String to_string(signed char value);
AMINO_CORE_SHARED_DECL String to_string(signed short value);
AMINO_CORE_SHARED_DECL String to_string(signed int value);
AMINO_CORE_SHARED_DECL String to_string(signed long long value);
AMINO_CORE_SHARED_DECL String to_string(unsigned char value);
AMINO_CORE_SHARED_DECL String to_string(unsigned short value);
AMINO_CORE_SHARED_DECL String to_string(unsigned int value);
AMINO_CORE_SHARED_DECL String to_string(unsigned long long value);
 
template <>
struct Internal::GetTypeCategory<String> {
    static constexpr auto value = TypeCategory::eStr;
};
 
//==============================================================================
// NAMESPACE StringLiterals
//==============================================================================
 
namespace StringLiterals {
 
inline String operator""_as(char const* data, size_t size) {
    return String{data, size};
}
 
} // namespace StringLiterals
 
} // namespace Amino
 
#endif