Some more work on asl::string_view

MODULE.bazel.lock

@@ -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": {},

asl/format.cpp

@@ -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)

asl/format.hpp

@@ -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);

asl/io.hpp

@@ -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

asl/layout.hpp

@@ -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;
+    isize_t size;
-    int64_t align;
+    isize_t align;
 
     constexpr bool operator==(const layout&) const = default;
 

asl/meta.hpp

@@ -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>;

asl/print.cpp

@@ -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);
     }

asl/span.hpp

@@ -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 };

asl/string_view.hpp

@@ -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));
+}

asl/tests/format_tests.cpp

@@ -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);

asl/tests/span_tests.cpp

@@ -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>,

asl/tests/string_view_tests.cpp

@@ -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());
+}