460nm/asl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Some more work on asl::string_view

Browse Source
This commit is contained in:
Steven Le Rouzic
2024-11-07 23:38:52 +01:00
parent 261076b35f
commit ac47be51b7
12 changed files with 89 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
MODULE.bazel.lock generated
View File

@ -64,20 +64,20 @@
"@@apple_support~//crosstool:setup.bzl%apple_cc_configure_extension": {
"general": {
"bzlTransitiveDigest": "PjIds3feoYE8SGbbIq2SFTZy3zmxeO2tQevJZNDo7iY=",
"usagesDigest": "aLmqbvowmHkkBPve05yyDNGN7oh7QE9kBADr3QIZTZs=",
"usagesDigest": "+hz7IHWN6A1oVJJWNDB6yZRG+RYhF76wAYItpAeIUIg=",
"recordedFileInputs": {},
"recordedDirentsInputs": {},
"envVariables": {},
"generatedRepoSpecs": {
"local_config_apple_cc": {
"bzlFile": "@@apple_support~//crosstool:setup.bzl",
"ruleClassName": "_apple_cc_autoconf",
"attributes": {}
},
"local_config_apple_cc_toolchains": {
"bzlFile": "@@apple_support~//crosstool:setup.bzl",
"ruleClassName": "_apple_cc_autoconf_toolchains",
"attributes": {}
},
"local_config_apple_cc": {
"bzlFile": "@@apple_support~//crosstool:setup.bzl",
"ruleClassName": "_apple_cc_autoconf",
"attributes": {}
}
},
"recordedRepoMappingEntries": [
@ -92,7 +92,7 @@
"@@platforms//host:extension.bzl%host_platform": {
"general": {
"bzlTransitiveDigest": "xelQcPZH8+tmuOHVjL9vDxMnnQNMlwj0SlvgoqBkm4U=",
"usagesDigest": "meSzxn3DUCcYEhq4HQwExWkWtU4EjriRBQLsZN+Q0SU=",
"usagesDigest": "pCYpDQmqMbmiiPI1p2Kd3VLm5T48rRAht5WdW0X2GlA=",
"recordedFileInputs": {},
"recordedDirentsInputs": {},
"envVariables": {},

2
asl/format.cpp
View File

@ -71,7 +71,7 @@ void asl::format_internals::format(
void asl::AslFormat(formatter& f, const char* str)
{
f.write(str, static_cast<int64_t>(__builtin_strlen(str)));
f.write(str, static_cast<isize_t>(__builtin_strlen(str)));
}
void asl::AslFormat(formatter& f, float)

4
asl/format.hpp
View File

@ -52,7 +52,7 @@ public:
{}
// @Todo Use string_view
constexpr void write(const char* s, int64_t len)
constexpr void write(const char* s, isize_t len)
{
m_writer->write(s, len);
}
@ -76,7 +76,7 @@ void format(writer* w, const char* fmt, const Args&... args)
}
}
template<int64_t N>
template<isize_t N>
void AslFormat(formatter& f, const char (&str)[N])
{
f.write(str, N - 1);

2
asl/io.hpp
View File

@ -14,7 +14,7 @@ public:
virtual ~writer() = default;
// @Todo Use string view, or span of bytes?
virtual void write(const char* str, int64_t len) = 0;
virtual void write(const char* str, isize_t len) = 0;
};
} // namespace asl

8
asl/layout.hpp
View File

@ -7,15 +7,15 @@ namespace asl
{
template<typename T>
inline constexpr int64_t size_of = static_cast<int64_t>(sizeof(T));
inline constexpr isize_t size_of = static_cast<isize_t>(sizeof(T));
template<typename T>
inline constexpr int64_t align_of = static_cast<int64_t>(alignof(T));
inline constexpr isize_t align_of = static_cast<isize_t>(alignof(T));
struct layout
{
int64_t size;
int64_t align;
isize_t size;
isize_t align;
constexpr bool operator==(const layout&) const = default;

2
asl/meta.hpp
View File

@ -8,7 +8,7 @@ struct empty {};
template<typename T> struct id { using type = T; };
template<typename... Args> static constexpr int64_t types_count = sizeof...(Args);
template<typename... Args> static constexpr isize_t types_count = sizeof...(Args);
template<typename T, T kValue> struct integral_constant { static constexpr T value = kValue; };
template<bool B> using bool_constant = integral_constant<bool, B>;

2
asl/print.cpp
View File

@ -12,7 +12,7 @@ public:
: m_handle{handle}
{}
void write(const char* str, int64_t len) override
void write(const char* str, isize_t len) override
{
fwrite(str, 1, static_cast<size_t>(len), m_handle);
}

36
asl/span.hpp
View File

@ -8,19 +8,19 @@
namespace asl
{
static constexpr int64_t dynamic_size = -1;
static constexpr isize_t dynamic_size = -1;
template<is_object T, int64_t kSize = dynamic_size>
template<is_object T, isize_t kSize = dynamic_size>
class span
{
static constexpr bool is_dynamic(int64_t size)
static constexpr bool is_dynamic(isize_t size)
{
return size < 0;
}
static constexpr bool kIsDynamic = is_dynamic(kSize);
using SizeType = select_t<kIsDynamic, int64_t, empty>;
using SizeType = select_t<kIsDynamic, isize_t, empty>;
T* m_data{};
ASL_NO_UNIQUE_ADDRESS SizeType m_size{};
@ -28,33 +28,33 @@ class span
public:
constexpr span() requires (kIsDynamic || kSize == 0) = default;
constexpr span(T* data, int64_t size)
constexpr span(T* data, isize_t size)
requires kIsDynamic
: m_data{data}
, m_size{size}
{}
constexpr explicit span(T* data, int64_t size)
constexpr explicit span(T* data, isize_t size)
requires (!kIsDynamic)
: m_data{data}
{
ASL_ASSERT(size == kSize);
}
template<int64_t N>
template<isize_t N>
constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
requires (kIsDynamic)
: m_data{array}
, m_size{N}
{}
template<int64_t N>
template<isize_t N>
constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
requires (!kIsDynamic) && (N == kSize)
: m_data{array}
{}
template<is_object U, int64_t kOtherSize>
template<is_object U, isize_t kOtherSize>
constexpr explicit(!kIsDynamic)
span(const span<U, kOtherSize>& other) // NOLINT(*-explicit-conversions)
requires (
@ -76,13 +76,13 @@ public:
~span() = default;
constexpr int64_t size() const
constexpr isize_t size() const
{
if constexpr (kIsDynamic) { return m_size; }
else { return kSize; }
}
constexpr int64_t size_bytes() const { return size() * size_of<T>; }
constexpr isize_t size_bytes() const { return size() * size_of<T>; }
constexpr bool is_empty() const { return size() == 0; }
@ -91,13 +91,13 @@ public:
constexpr T* begin() const { return m_data; }
constexpr T* end() const { return m_data + size(); }
constexpr T& operator[](int64_t i) const
constexpr T& operator[](isize_t i) const
{
ASL_ASSERT(i >= 0 && i < size());
return m_data[i]; // NOLINT(*-pointer-arithmetic)
}
template<int64_t kOffset, int64_t kSubSize = dynamic_size>
template<isize_t kOffset, isize_t kSubSize = dynamic_size>
constexpr auto subspan() const
requires (
kOffset >= 0 &&
@ -125,7 +125,7 @@ public:
}
}
constexpr span<T> subspan(int64_t offset, int64_t sub_size = dynamic_size) const
constexpr span<T> subspan(isize_t offset, isize_t sub_size = dynamic_size) const
{
ASL_ASSERT(offset <= size());
@ -138,7 +138,7 @@ public:
return span<T>{ data() + offset, sub_size };
}
template<int64_t kSubSize>
template<isize_t kSubSize>
constexpr auto first() const
requires (
kSubSize >= 0 &&
@ -149,13 +149,13 @@ public:
return span<T, kSubSize>{ data(), kSubSize };
}
constexpr span<T> first(int64_t sub_size) const
constexpr span<T> first(isize_t sub_size) const
{
ASL_ASSERT(sub_size >= 0 && sub_size <= size());
return span<T>{ data(), sub_size };
}
template<int64_t kSubSize>
template<isize_t kSubSize>
constexpr auto last() const
requires (
kSubSize >= 0 &&
@ -166,7 +166,7 @@ public:
return span<T, kSubSize>{ data() + size() - kSubSize, kSubSize };
}
constexpr span<T> last(int64_t sub_size) const
constexpr span<T> last(isize_t sub_size) const
{
ASL_ASSERT(sub_size >= 0 && sub_size <= size());
return span<T>{ data() + size() - sub_size, sub_size };

26
asl/string_view.hpp
View File

@ -6,26 +6,23 @@
namespace asl
{
// @Todo Replace all the __builtin_strlen
class string_view
{
const char* m_data{};
int64_t m_size{};
isize_t m_size{};
public:
constexpr string_view() = default;
constexpr string_view(nullptr_t) : string_view() {} // NOLINT(*-explicit-conversions)
constexpr string_view(const char* data, int64_t size)
constexpr string_view(const char* data, isize_t size)
: m_data{data}
, m_size{size}
{}
constexpr string_view(const char* data) // NOLINT(*-explicit-conversions)
: m_data{data}
, m_size{static_cast<int64_t>(__builtin_strlen(data))}
{}
constexpr string_view(const string_view&) = default;
constexpr string_view(string_view&&) = default;
@ -33,6 +30,21 @@ public:
constexpr string_view& operator=(string_view&&) = default;
~string_view() = default;
constexpr isize_t size() const { return m_size; }
constexpr bool is_empty() const { return m_size == 0; }
constexpr const char* data() const { return m_data; }
constexpr const char* begin() const { return m_data; }
constexpr const char* end() const { return m_data + m_size; } // NOLINT(*-pointer-arithmetic)
};
} // namespace asl
constexpr asl::string_view operator ""_sv(const char* s, size_t len)
{
return asl::string_view(s, static_cast<isize_t>(len));
}

4
asl/tests/format_tests.cpp
View File

@ -12,11 +12,11 @@ static_assert(asl::formattable<decltype("Hello")>);
class StringSink : public asl::writer
{
int64_t m_current_len{};
isize_t m_current_len{};
char* m_data{};
public:
void write(const char* str, int64_t len) override
void write(const char* str, isize_t len) override
{
m_data = (char*)realloc(m_data, (size_t)(m_current_len + len + 1));
memcpy(m_data + m_current_len, str, (size_t)len);

18
asl/tests/span_tests.cpp
View File

@ -94,14 +94,14 @@ ASL_TEST(conversion)
ASL_TEST_EXPECT(span4[2] == 3);
}
template<typename Span, int64_t kOffset, int64_t kSize = asl::dynamic_size>
template<typename Span, isize_t kOffset, isize_t kSize = asl::dynamic_size>
[[maybe_unused]] static auto try_static_subspan(int)
-> decltype(asl::declval<Span>().template subspan<kOffset, kSize>());
template<typename, int64_t, int64_t>
template<typename, isize_t, isize_t>
[[maybe_unused]] static auto try_static_subspan(...) -> asl::empty;
template<typename Span, int64_t kOffset, int64_t kSize = asl::dynamic_size>
template<typename Span, isize_t kOffset, isize_t kSize = asl::dynamic_size>
concept invalid_subspan = asl::same_as<decltype(try_static_subspan<Span, kOffset, kSize>(0)), asl::empty>;
static_assert(asl::same_as<asl::span<int, 4>,
@ -216,14 +216,14 @@ ASL_TEST(subspan_dynamic)
ASL_TEST_EXPECT(s4[1] == 3);
}
template<typename Span, int64_t kSize>
template<typename Span, isize_t kSize>
[[maybe_unused]] static auto try_static_first(int)
-> decltype(asl::declval<Span>().template first<kSize>());
template<typename, int64_t>
template<typename, isize_t>
[[maybe_unused]] static auto try_static_first(...) -> asl::empty;
template<typename Span, int64_t kSize>
template<typename Span, isize_t kSize>
concept invalid_first = asl::same_as<decltype(try_static_first<Span, kSize>(0)), asl::empty>;
static_assert(asl::same_as<asl::span<int, 0>,
@ -320,14 +320,14 @@ ASL_TEST(first_dynamic)
ASL_TEST_EXPECT(s3[3] == 4);
}
template<typename Span, int64_t kSize>
template<typename Span, isize_t kSize>
[[maybe_unused]] static auto try_static_last(int)
-> decltype(asl::declval<Span>().template last<kSize>());
template<typename, int64_t>
template<typename, isize_t>
[[maybe_unused]] static auto try_static_last(...) -> asl::empty;
template<typename Span, int64_t kSize>
template<typename Span, isize_t kSize>
concept invalid_last = asl::same_as<decltype(try_static_last<Span, kSize>(0)), asl::empty>;
static_assert(asl::same_as<asl::span<int, 0>,

24
asl/tests/string_view_tests.cpp
View File

@ -1,3 +1,27 @@
#include "asl/string_view.hpp"
#include "asl/testing/testing.hpp"
// @Todo Don't use stdlib, remake memcmp
#include <string.h>
static_assert(asl::trivially_destructible<asl::string_view>);
static_assert(asl::trivially_copyable<asl::string_view>);
ASL_TEST(default)
{
asl::string_view s1;
ASL_TEST_EXPECT(s1.is_empty());
asl::string_view s2 = nullptr;
ASL_TEST_EXPECT(s2.is_empty());
}
ASL_TEST(from_literal)
{
asl::string_view s1 = "Hello"_sv;
ASL_TEST_ASSERT(s1.size() == 5);
ASL_TEST_EXPECT(memcmp(s1.data(), "Hello", 5) == 0);
asl::string_view s2 = ""_sv;
ASL_TEST_EXPECT(s2.is_empty());
}