Program Listing for File slint_string.h

↰ Return to documentation for file (/home/runner/work/slint/slint/api/cpp/include/slint_string.h)

// Copyright © SixtyFPS GmbH <[email protected]>
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0

#pragma once
#include <string_view>
#include <span>
#include "slint_string_internal.h"

namespace slint {

struct SharedString
{
    SharedString() { cbindgen_private::slint_shared_string_from_bytes(this, "", 0); }
    SharedString(std::string_view s)
    {
        cbindgen_private::slint_shared_string_from_bytes(this, s.data(), s.size());
    }
    SharedString(const char *s) : SharedString(std::string_view(s)) { }
    SharedString(const char8_t *s) : SharedString(reinterpret_cast<const char *>(s)) { }
    SharedString(std::u8string_view s)
    {
        cbindgen_private::slint_shared_string_from_bytes(
                this, reinterpret_cast<const char *>(s.data()), s.size());
    }
    SharedString(const SharedString &other)
    {
        cbindgen_private::slint_shared_string_clone(this, &other);
    }
    ~SharedString() { cbindgen_private::slint_shared_string_drop(this); }
    SharedString &operator=(const SharedString &other)
    {
        cbindgen_private::slint_shared_string_drop(this);
        cbindgen_private::slint_shared_string_clone(this, &other);
        return *this;
    }
    SharedString &operator=(std::string_view s)
    {
        cbindgen_private::slint_shared_string_drop(this);
        cbindgen_private::slint_shared_string_from_bytes(this, s.data(), s.size());
        return *this;
    }
    SharedString &operator=(const char *s) { return *this = std::string_view(s); }

    SharedString &operator=(SharedString &&other)
    {
        std::swap(inner, other.inner);
        return *this;
    }

    operator std::string_view() const { return cbindgen_private::slint_shared_string_bytes(this); }
    auto data() const -> const char * { return cbindgen_private::slint_shared_string_bytes(this); }
    std::size_t size() const { return std::string_view(*this).size(); }

    const char *begin() const { return data(); }
    const char *end() const
    {
        std::string_view view(*this);
        return view.data() + view.size();
    }

    bool empty() const { return std::string_view(*this).empty(); }

    bool starts_with(std::string_view prefix) const
    {
        return std::string_view(*this).substr(0, prefix.size()) == prefix;
    }

    bool ends_with(std::string_view prefix) const
    {
        std::string_view self_view(*this);
        return self_view.size() >= prefix.size()
                && self_view.compare(self_view.size() - prefix.size(), std::string_view::npos,
                                     prefix)
                == 0;
    }

    void clear() { *this = std::string_view("", 0); }

    static SharedString from_number(double n) { return SharedString(n); }

    SharedString to_lowercase() const
    {
        auto out = SharedString();
        cbindgen_private::slint_shared_string_to_lowercase(&out, this);
        return out;
    }

    SharedString to_uppercase() const
    {
        auto out = SharedString();
        cbindgen_private::slint_shared_string_to_uppercase(&out, this);
        return out;
    }

    friend bool operator==(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) == std::string_view(b);
    }
    friend bool operator!=(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) != std::string_view(b);
    }

    friend bool operator<(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) < std::string_view(b);
    }
    friend bool operator<=(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) <= std::string_view(b);
    }
    friend bool operator>(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) > std::string_view(b);
    }
    friend bool operator>=(const SharedString &a, const SharedString &b)
    {
        return std::string_view(a) >= std::string_view(b);
    }

    friend std::ostream &operator<<(std::ostream &stream, const SharedString &shared_string)
    {
        return stream << std::string_view(shared_string);
    }

    friend SharedString operator+(const SharedString &a, std::string_view b)
    {
        SharedString a2 = a;
        return a2 += b;
    }
    friend SharedString operator+(SharedString &&a, std::string_view b)
    {
        a += b;
        return a;
    }
    SharedString &operator+=(std::string_view other)
    {
        cbindgen_private::slint_shared_string_append(this, other.data(), other.size());
        return *this;
    }

private:
    explicit SharedString(double n) { cbindgen_private::slint_shared_string_from_number(this, n); }
    void *inner; // opaque
};

namespace private_api {

template<typename T>
inline cbindgen_private::Slice<T> make_slice(const T *ptr, size_t len)
{
    return cbindgen_private::Slice<T> {
        // Rust uses a NonNull, so even empty slices shouldn't use nullptr
        .ptr = ptr ? const_cast<T *>(ptr) : reinterpret_cast<T *>(sizeof(T)),
        .len = len,
    };
}

template<typename T, size_t Extent>
inline cbindgen_private::Slice<std::remove_const_t<T>> make_slice(std::span<T, Extent> span)
{
    return make_slice(span.data(), span.size());
}

inline cbindgen_private::Slice<uint8_t> string_to_slice(std::string_view str)
{
    return make_slice(reinterpret_cast<const uint8_t *>(str.data()), str.size());
}
}

}