From 605b62cd29a5d6a20211f1b4d8eb602ac5bb271c Mon Sep 17 00:00:00 2001 From: Lukas Tenbrink Date: Thu, 16 Jan 2025 19:48:50 +0100 Subject: [PATCH] Add `Span` struct (replacing `StrRange`). Spans represent read-only access to a contiguous array, resembling `std::span`. --- core/string/ustring.cpp | 32 ++++---- core/string/ustring.h | 77 ++++++++----------- core/templates/cowdata.h | 4 + core/templates/span.h | 62 +++++++++++++++ core/templates/vector.h | 6 +- .../renderer_rd/effects/sort_effects.h | 1 + tests/core/templates/test_span.h | 60 +++++++++++++++ tests/test_main.cpp | 1 + 8 files changed, 179 insertions(+), 64 deletions(-) create mode 100644 core/templates/span.h create mode 100644 tests/core/templates/test_span.h diff --git a/core/string/ustring.cpp b/core/string/ustring.cpp index 49c46747c0f..04b1764591c 100644 --- a/core/string/ustring.cpp +++ b/core/string/ustring.cpp @@ -299,16 +299,16 @@ Error String::parse_url(String &r_scheme, String &r_host, int &r_port, String &r return OK; } -void String::parse_latin1(const StrRange &p_cstr) { - if (p_cstr.len == 0) { +void String::parse_latin1(const Span &p_cstr) { + if (p_cstr.size() == 0) { resize(0); return; } - resize(p_cstr.len + 1); // include 0 + resize(p_cstr.size() + 1); // include 0 - const char *src = p_cstr.c_str; - const char *end = src + p_cstr.len; + const char *src = p_cstr.ptr(); + const char *end = src + p_cstr.size(); char32_t *dst = ptrw(); for (; src < end; ++src, ++dst) { @@ -318,13 +318,13 @@ void String::parse_latin1(const StrRange &p_cstr) { *dst = 0; } -void String::parse_utf32(const StrRange &p_cstr) { - if (p_cstr.len == 0) { +void String::parse_utf32(const Span &p_cstr) { + if (p_cstr.size() == 0) { resize(0); return; } - copy_from_unchecked(p_cstr.c_str, p_cstr.len); + copy_from_unchecked(p_cstr.ptr(), p_cstr.size()); } void String::parse_utf32(const char32_t &p_char) { @@ -564,8 +564,8 @@ bool String::operator==(const String &p_str) const { return memcmp(ptr(), p_str.ptr(), length() * sizeof(char32_t)) == 0; } -bool String::operator==(const StrRange &p_str_range) const { - const int len = p_str_range.len; +bool String::operator==(const Span &p_str_range) const { + const int len = p_str_range.size(); if (length() != len) { return false; @@ -574,7 +574,7 @@ bool String::operator==(const StrRange &p_str_range) const { return true; } - return memcmp(ptr(), p_str_range.c_str, len * sizeof(char32_t)) == 0; + return memcmp(ptr(), p_str_range.ptr(), len * sizeof(char32_t)) == 0; } bool operator==(const char *p_chr, const String &p_str) { @@ -1921,16 +1921,16 @@ CharString String::ascii(bool p_allow_extended) const { return cs; } -Error String::parse_ascii(const StrRange &p_range) { - if (p_range.len == 0) { +Error String::parse_ascii(const Span &p_range) { + if (p_range.size() == 0) { resize(0); return OK; } - resize(p_range.len + 1); // Include \0 + resize(p_range.size() + 1); // Include \0 - const char *src = p_range.c_str; - const char *end = src + p_range.len; + const char *src = p_range.ptr(); + const char *end = src + p_range.size(); char32_t *dst = ptrw(); bool decode_failed = false; diff --git a/core/string/ustring.h b/core/string/ustring.h index 8670dc97ce8..cffcbe280c5 100644 --- a/core/string/ustring.h +++ b/core/string/ustring.h @@ -97,30 +97,6 @@ constexpr size_t _strlen_clipped(const char32_t *p_str, int p_clip_to_len) { return len; } -/*************************************************************************/ -/* StrRange */ -/*************************************************************************/ - -template -struct StrRange { - const Element *c_str; - size_t len; - - explicit StrRange(const std::nullptr_t p_cstring) : - c_str(nullptr), len(0) {} - - explicit StrRange(const Element *p_cstring, const size_t p_len) : - c_str(p_cstring), len(p_len) {} - - template - explicit StrRange(const Element (&p_cstring)[len]) : - c_str(p_cstring), len(strlen(p_cstring)) {} - - static StrRange from_c_str(const Element *p_cstring) { - return StrRange(p_cstring, p_cstring ? strlen(p_cstring) : 0); - } -}; - /*************************************************************************/ /* CharProxy */ /*************************************************************************/ @@ -177,6 +153,10 @@ public: _FORCE_INLINE_ char16_t *ptrw() { return _cowdata.ptrw(); } _FORCE_INLINE_ const char16_t *ptr() const { return _cowdata.ptr(); } _FORCE_INLINE_ int size() const { return _cowdata.size(); } + + _FORCE_INLINE_ operator Span() const { return Span(ptr(), length()); } + _FORCE_INLINE_ Span span() const { return Span(ptr(), length()); } + Error resize(int p_size) { return _cowdata.resize(p_size); } _FORCE_INLINE_ char16_t get(int p_index) const { return _cowdata.get(p_index); } @@ -203,7 +183,6 @@ public: Char16String &operator+=(char16_t p_char); int length() const { return size() ? size() - 1 : 0; } const char16_t *get_data() const; - operator StrRange() const { return StrRange(get_data(), length()); } protected: void copy_from(const char16_t *p_cstr); @@ -221,6 +200,10 @@ public: _FORCE_INLINE_ char *ptrw() { return _cowdata.ptrw(); } _FORCE_INLINE_ const char *ptr() const { return _cowdata.ptr(); } _FORCE_INLINE_ int size() const { return _cowdata.size(); } + + _FORCE_INLINE_ operator Span() const { return Span(ptr(), length()); } + _FORCE_INLINE_ Span span() const { return Span(ptr(), length()); } + Error resize(int p_size) { return _cowdata.resize(p_size); } _FORCE_INLINE_ char get(int p_index) const { return _cowdata.get(p_index); } @@ -248,7 +231,6 @@ public: CharString &operator+=(char p_char); int length() const { return size() ? size() - 1 : 0; } const char *get_data() const; - operator StrRange() const { return StrRange(get_data(), length()); } protected: void copy_from(const char *p_cstr); @@ -264,33 +246,33 @@ class String { static const char32_t _replacement_char; // Known-length copy. - void parse_latin1(const StrRange &p_cstr); - void parse_utf32(const StrRange &p_cstr); + void parse_latin1(const Span &p_cstr); + void parse_utf32(const Span &p_cstr); void parse_utf32(const char32_t &p_char); void copy_from_unchecked(const char32_t *p_char, int p_length); // NULL-terminated c string copy - automatically parse the string to find the length. void parse_latin1(const char *p_cstr) { - parse_latin1(StrRange::from_c_str(p_cstr)); + parse_latin1(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0)); } void parse_latin1(const char *p_cstr, int p_clip_to) { - parse_latin1(StrRange(p_cstr, p_cstr ? _strlen_clipped(p_cstr, p_clip_to) : 0)); + parse_latin1(Span(p_cstr, p_cstr ? _strlen_clipped(p_cstr, p_clip_to) : 0)); } void parse_utf32(const char32_t *p_cstr) { - parse_utf32(StrRange::from_c_str(p_cstr)); + parse_utf32(Span(p_cstr, p_cstr ? strlen(p_cstr) : 0)); } void parse_utf32(const char32_t *p_cstr, int p_clip_to) { - parse_utf32(StrRange(p_cstr, p_cstr ? _strlen_clipped(p_cstr, p_clip_to) : 0)); + parse_utf32(Span(p_cstr, p_cstr ? _strlen_clipped(p_cstr, p_clip_to) : 0)); } // wchar_t copy_from depends on the platform. - void parse_wstring(const StrRange &p_cstr) { + void parse_wstring(const Span &p_cstr) { #ifdef WINDOWS_ENABLED // wchar_t is 16-bit, parse as UTF-16 - parse_utf16((const char16_t *)p_cstr.c_str, p_cstr.len); + parse_utf16((const char16_t *)p_cstr.ptr(), p_cstr.size()); #else // wchar_t is 32-bit, copy directly - parse_utf32((StrRange &)p_cstr); + parse_utf32((Span &)p_cstr); #endif } void parse_wstring(const wchar_t *p_cstr) { @@ -324,6 +306,10 @@ public: _FORCE_INLINE_ char32_t *ptrw() { return _cowdata.ptrw(); } _FORCE_INLINE_ const char32_t *ptr() const { return _cowdata.ptr(); } + _FORCE_INLINE_ int size() const { return _cowdata.size(); } + + _FORCE_INLINE_ operator Span() const { return Span(ptr(), length()); } + _FORCE_INLINE_ Span span() const { return Span(ptr(), length()); } void remove_at(int p_index) { _cowdata.remove_at(p_index); } @@ -331,7 +317,6 @@ public: _FORCE_INLINE_ char32_t get(int p_index) const { return _cowdata.get(p_index); } _FORCE_INLINE_ void set(int p_index, const char32_t &p_elem) { _cowdata.set(p_index, p_elem); } - _FORCE_INLINE_ int size() const { return _cowdata.size(); } Error resize(int p_size) { return _cowdata.resize(p_size); } _FORCE_INLINE_ const char32_t &operator[](int p_index) const { @@ -359,7 +344,7 @@ public: bool operator==(const char *p_str) const; bool operator==(const wchar_t *p_str) const; bool operator==(const char32_t *p_str) const; - bool operator==(const StrRange &p_str_range) const; + bool operator==(const Span &p_str_range) const; bool operator!=(const char *p_str) const; bool operator!=(const wchar_t *p_str) const; @@ -520,8 +505,8 @@ public: CharString ascii(bool p_allow_extended = false) const; // Parse an ascii string. // If any character is > 127, an error will be logged, and 0xfffd will be inserted. - Error parse_ascii(const StrRange &p_range); - static String ascii(const StrRange &p_range) { + Error parse_ascii(const Span &p_range); + static String ascii(const Span &p_range) { String s; s.parse_ascii(p_range); return s; @@ -529,19 +514,19 @@ public: CharString utf8() const; Error parse_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false); - Error parse_utf8(const StrRange &p_range, bool p_skip_cr = false) { - return parse_utf8(p_range.c_str, p_range.len, p_skip_cr); + Error parse_utf8(const Span &p_range, bool p_skip_cr = false) { + return parse_utf8(p_range.ptr(), p_range.size(), p_skip_cr); } static String utf8(const char *p_utf8, int p_len = -1); - static String utf8(const StrRange &p_range) { return utf8(p_range.c_str, p_range.len); } + static String utf8(const Span &p_range) { return utf8(p_range.ptr(), p_range.size()); } Char16String utf16() const; Error parse_utf16(const char16_t *p_utf16, int p_len = -1, bool p_default_little_endian = true); - Error parse_utf16(const StrRange p_range, bool p_skip_cr = false) { - return parse_utf16(p_range.c_str, p_range.len, p_skip_cr); + Error parse_utf16(const Span p_range, bool p_skip_cr = false) { + return parse_utf16(p_range.ptr(), p_range.size(), p_skip_cr); } static String utf16(const char16_t *p_utf16, int p_len = -1); - static String utf16(const StrRange &p_range) { return utf16(p_range.c_str, p_range.len); } + static String utf16(const Span &p_range) { return utf16(p_range.ptr(), p_range.size()); } static uint32_t hash(const char32_t *p_cstr, int p_len); /* hash the string */ static uint32_t hash(const char32_t *p_cstr); /* hash the string */ @@ -655,8 +640,6 @@ public: void operator=(const char32_t *p_cstr) { parse_utf32(p_cstr); } - - operator StrRange() const { return StrRange(get_data(), length()); } }; bool operator==(const char *p_chr, const String &p_str); diff --git a/core/templates/cowdata.h b/core/templates/cowdata.h index a4e3d7d8839..60280e4dc67 100644 --- a/core/templates/cowdata.h +++ b/core/templates/cowdata.h @@ -33,6 +33,7 @@ #include "core/error/error_macros.h" #include "core/os/memory.h" #include "core/templates/safe_refcount.h" +#include "core/templates/span.h" #include #include @@ -248,6 +249,9 @@ public: return OK; } + _FORCE_INLINE_ operator Span() const { return Span(ptr(), size()); } + _FORCE_INLINE_ Span span() const { return operator Span(); } + Size find(const T &p_val, Size p_from = 0) const; Size rfind(const T &p_val, Size p_from = -1) const; Size count(const T &p_val) const; diff --git a/core/templates/span.h b/core/templates/span.h new file mode 100644 index 00000000000..872fc7b6585 --- /dev/null +++ b/core/templates/span.h @@ -0,0 +1,62 @@ +/**************************************************************************/ +/* span.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +#include "core/typedefs.h" + +// Equivalent of std::span. +// Represents a view into a contiguous memory space. +// DISCLAIMER: This data type does not own the underlying buffer. DO NOT STORE IT. +// Additionally, for the lifetime of the Span, do not resize the buffer, and do not insert or remove elements from it. +// Failure to respect this may lead to crashes or undefined behavior. +template +class Span { + const T *_ptr = nullptr; + uint64_t _len = 0; + +public: + _FORCE_INLINE_ constexpr Span() = default; + _FORCE_INLINE_ constexpr Span(const T *p_ptr, uint64_t p_len) : + _ptr(p_ptr), _len(p_len) {} + + _FORCE_INLINE_ constexpr uint64_t size() const { return _len; } + _FORCE_INLINE_ constexpr bool is_empty() const { return _len == 0; } + + _FORCE_INLINE_ constexpr const T *ptr() const { return _ptr; } + + // NOTE: Span subscripts sanity check the bounds to avoid undefined behavior. + // This is slower than direct buffer access and can prevent autovectorization. + // If the bounds are known, use ptr() subscript instead. + _FORCE_INLINE_ constexpr const T &operator[](uint64_t p_idx) const { + CRASH_COND(p_idx >= _len); + return _ptr[p_idx]; + } +}; diff --git a/core/templates/vector.h b/core/templates/vector.h index a555b9d0ec1..c8daf957fa2 100644 --- a/core/templates/vector.h +++ b/core/templates/vector.h @@ -89,13 +89,17 @@ public: _FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); } _FORCE_INLINE_ const T *ptr() const { return _cowdata.ptr(); } + _FORCE_INLINE_ Size size() const { return _cowdata.size(); } + + _FORCE_INLINE_ operator Span() const { return _cowdata.span(); } + _FORCE_INLINE_ Span span() const { return _cowdata.span(); } + _FORCE_INLINE_ void clear() { resize(0); } _FORCE_INLINE_ bool is_empty() const { return _cowdata.is_empty(); } _FORCE_INLINE_ T get(Size p_index) { return _cowdata.get(p_index); } _FORCE_INLINE_ const T &get(Size p_index) const { return _cowdata.get(p_index); } _FORCE_INLINE_ void set(Size p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } - _FORCE_INLINE_ Size size() const { return _cowdata.size(); } Error resize(Size p_size) { return _cowdata.resize(p_size); } Error resize_zeroed(Size p_size) { return _cowdata.template resize(p_size); } _FORCE_INLINE_ const T &operator[](Size p_index) const { return _cowdata.get(p_index); } diff --git a/servers/rendering/renderer_rd/effects/sort_effects.h b/servers/rendering/renderer_rd/effects/sort_effects.h index 1ebbfc3a06f..fce5e8eed6d 100644 --- a/servers/rendering/renderer_rd/effects/sort_effects.h +++ b/servers/rendering/renderer_rd/effects/sort_effects.h @@ -30,6 +30,7 @@ #pragma once +#include "servers/rendering/renderer_rd/shader_rd.h" #include "servers/rendering/renderer_rd/shaders/effects/sort.glsl.gen.h" namespace RendererRD { diff --git a/tests/core/templates/test_span.h b/tests/core/templates/test_span.h new file mode 100644 index 00000000000..e3b4f469484 --- /dev/null +++ b/tests/core/templates/test_span.h @@ -0,0 +1,60 @@ +/**************************************************************************/ +/* test_span.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +#include "core/templates/span.h" + +#include "tests/test_macros.h" + +namespace TestSpan { + +TEST_CASE("[Span] Constexpr Validators") { + constexpr Span span_empty; + static_assert(span_empty.ptr() == nullptr); + static_assert(span_empty.size() == 0); + static_assert(span_empty.is_empty()); + + constexpr static uint16_t value = 5; + constexpr Span span_value(&value, 1); + static_assert(span_value.ptr() == &value); + static_assert(span_value.size() == 1); + static_assert(!span_value.is_empty()); + + constexpr static char32_t array[] = U"122345"; + constexpr Span span_array(array, strlen(array)); + static_assert(span_array.ptr() == &array[0]); + static_assert(span_array.size() == 6); + static_assert(!span_array.is_empty()); + static_assert(span_array[0] == U'1'); + static_assert(span_array[span_array.size() - 1] == U'5'); +} + +} // namespace TestSpan diff --git a/tests/test_main.cpp b/tests/test_main.cpp index 2d8f2c76915..71de3b6120b 100644 --- a/tests/test_main.cpp +++ b/tests/test_main.cpp @@ -102,6 +102,7 @@ #include "tests/core/templates/test_oa_hash_map.h" #include "tests/core/templates/test_paged_array.h" #include "tests/core/templates/test_rid.h" +#include "tests/core/templates/test_span.h" #include "tests/core/templates/test_vector.h" #include "tests/core/test_crypto.h" #include "tests/core/test_hashing_context.h"