Add contiguous iterators

asl/buffer.hpp

@@ -357,6 +357,13 @@ public:
         }
     }
 
+    // @Todo(C++23) Use deducing this
+    constexpr contiguous_iterator<const T> begin() const { return contiguous_iterator{data()}; }
+    constexpr contiguous_iterator<const T> end() const { return contiguous_iterator{data() + size()}; }
+    
+    constexpr contiguous_iterator<T> begin() { return contiguous_iterator{data()}; }
+    constexpr contiguous_iterator<T> end() { return contiguous_iterator{data() + size()}; }
+
     // @Todo(C++23) Deducing this
     constexpr operator span<const T>() const // NOLINT(*-explicit-conversions)
     {

asl/format.cpp

@@ -10,8 +10,8 @@ void asl::format_internals::format(
 {
     Formatter f(writer);
 
-    const auto* arg_it = args.begin();
+    auto arg_it = args.begin();
-    const auto* arg_end = args.end();
+    auto arg_end = args.end();
     
     isize_t i = 0;
     while (i < fmt.size())
@@ -22,23 +22,19 @@ void asl::format_internals::format(
             {
                 if (fmt[i + 1] == '}')
                 {
-                    if (arg_it >= arg_end)
+                    f.write(fmt.substr(0, i));
+                    fmt = fmt.substr(i + 2);
+                    i = 0;
+
+                    if (arg_it == arg_end)
                     {
-                        f.write(fmt.substr(0, i));
-                        fmt = fmt.substr(i + 2);
-                        i = 0;
-
                         f.write("<ERROR>");
-
-                        continue;
                     }
-                    
+                    else
-                    f.write(fmt.substr(0, i));
+                    {
-                    fmt = fmt.substr(i + 2);
-                    i = 0;
-
                         arg_it->fn(f, arg_it->data);
-                    arg_it++; // NOLINT(*-pointer-arithmetic)
+                        arg_it++;
+                    }
 
                     continue;
                 }

asl/hash_map.hpp

@@ -147,9 +147,23 @@ public:
         // NOLINTEND(*-pointer-arithmetic)
     }
     
+    // @Todo(C++23) Deducing this
     template<typename U>
     requires key_hasher<KeyHasher, U> && key_comparator<KeyComparator, K, U>
-    V* get(const U& value) const
+    const V* get(const U& value) const
+    {
+        isize_t index = Base::find_slot_lookup(value);
+        if (index >= 0)
+        {
+            // NOLINTNEXTLINE(*-pointer-arithmetic)
+            return &Base::m_values[index].as_init_unsafe().value;
+        }
+        return nullptr;
+    }
+    
+    template<typename U>
+    requires key_hasher<KeyHasher, U> && key_comparator<KeyComparator, K, U>
+    V* get(const U& value)
     {
         isize_t index = Base::find_slot_lookup(value);
         if (index >= 0)

asl/span.hpp

@@ -10,6 +10,38 @@ namespace asl
 
 static constexpr isize_t dynamic_size = -1;
 
+template<typename T>
+class contiguous_iterator
+{
+    T* m_ptr;
+
+public:
+    constexpr explicit contiguous_iterator(T* ptr) : m_ptr{ptr} {}
+
+    constexpr bool operator==(const contiguous_iterator& other) const
+    {
+        return other.m_ptr == m_ptr;
+    }
+
+    constexpr contiguous_iterator& operator++()
+    {
+        m_ptr += 1;
+        return *this;
+    }
+
+    constexpr contiguous_iterator operator++(int)
+    {
+        return contiguous_iterator{ exchange(m_ptr, m_ptr + 1) };
+    }
+
+    constexpr T& operator*() const { return *m_ptr; }
+
+    constexpr T* operator->() const { return m_ptr; }
+};
+
+template<typename T>
+contiguous_iterator(T) -> contiguous_iterator<T>;
+
 template<is_object T, isize_t kSize = dynamic_size>
 class span
 {
@@ -88,8 +120,15 @@ public:
 
     constexpr T* data() const { return m_data; }
 
-    constexpr T* begin() const { return m_data; }
+    constexpr contiguous_iterator<T> begin() const
-    constexpr T* end() const { return m_data + size(); }
+    {
+        return contiguous_iterator{m_data};
+    }
+    
+    constexpr contiguous_iterator<T> end() const
+    {
+        return contiguous_iterator{m_data + size()};
+    }
 
     constexpr T& operator[](isize_t i) const
     {

asl/string_view.hpp

@@ -46,9 +46,10 @@ public:
 
     constexpr const char* data() const { return m_data; }
 
-    constexpr const char* begin() const { return m_data; }
+    constexpr contiguous_iterator<const char> begin() const { return contiguous_iterator{m_data}; }
 
-    constexpr const char* end() const { return m_data + m_size; } // NOLINT(*-pointer-arithmetic)
+    // NOLINTNEXTLINE(*-pointer-arithmetic)
+    constexpr contiguous_iterator<const char> end() const { return contiguous_iterator{m_data + m_size}; }
 
     constexpr span<const char> as_span() const { return span<const char>(m_data, m_size); }
 

todo.txt

@@ -1,5 +1,4 @@
-hashing
-hash_set
-hash_map
 logging
 dynlib
+
+warning compare with 0 in format_float.cpp