alloc: prefer std::byte representations for iterators

this allows the users to more easily walk the byte ranges (or perform
simply pointer arithmetic), without as much danger of using the values
in an expression inadvertantly.

alloc/raw/affix.hpp

@@ -35,8 +35,11 @@ namespace util::alloc::raw {
         void  deallocate (void *ptr, size_t bytes);
         void  deallocate (void *ptr, size_t bytes, size_t align);
 
-        void* begin (void);
+        std::byte* begin (void);
-        const void* begin (void) const;
+        const std::byte* begin (void) const;
+
+        std::byte* end (void);
+        const std::byte* end (void) const;
 
         size_t offset (const void*) const;
     };

alloc/raw/aligned.hpp

@@ -77,6 +77,8 @@ namespace util::alloc::raw {
         auto begin (void)       { return m_successor.begin (); }
         auto begin (void) const { return m_successor.begin (); }
 
+        auto end (void)       { return m_successor.end (); }
+        auto end (void) const { return m_successor.end (); }
 
         //---------------------------------------------------------------------
         auto

alloc/raw/dynamic.hpp

@@ -93,9 +93,12 @@ namespace util::alloc::raw {
             virtual void deallocate (void *ptr, size_t bytes) = 0;
             virtual void deallocate (void *ptr, size_t bytes, size_t alignment) = 0;
 
-            virtual void*       begin (void) = 0;
+            virtual       std::byte* begin (void) = 0;
-            virtual const void* begin (void) const = 0;
+            virtual const std::byte* begin (void) const = 0;
-            virtual size_t      offset (const void*) const = 0;
+            virtual       std::byte* end (void) = 0;
+            virtual const std::byte* end (void) const = 0;
+
+            virtual size_t offset (const void*) const = 0;
 
             virtual void reset (void) = 0;
 
@@ -132,14 +135,22 @@ namespace util::alloc::raw {
             deallocate (void *ptr, size_t bytes, size_t alignment) override
             { m_target.deallocate (ptr, bytes, alignment); }
 
-            const void*
+            const std::byte*
             begin (void) const override
             { return m_target.begin (); }
 
-            void*
+            std::byte*
             begin (void) override
             { return m_target.begin (); }
 
+            std::byte*
+            end (void) override
+            { return m_target.end (); }
+
+            const std::byte*
+            end (void) const override
+            { return m_target.end (); }
+
             size_t
             offset (const void *ptr) const override
             { return m_target.offset (ptr); }

alloc/raw/linear.cpp

@@ -24,9 +24,9 @@ using util::alloc::raw::linear;
 
 ///////////////////////////////////////////////////////////////////////////////
 linear::linear (void *begin, void *end):
-    m_begin  (reinterpret_cast<char*> (begin)),
+    m_begin  (reinterpret_cast<std::byte*> (begin)),
-    m_end    (reinterpret_cast<char*> (end)),
+    m_end    (reinterpret_cast<std::byte*> (end)),
-    m_cursor (reinterpret_cast<char*> (begin))
+    m_cursor (reinterpret_cast<std::byte*> (begin))
 {
     CHECK_NEZ (begin);
     CHECK_NEZ (end);
@@ -76,7 +76,7 @@ linear::deallocate (void *ptr, size_t bytes, size_t alignment)
 
 
 //-----------------------------------------------------------------------------
-void*
+std::byte*
 linear::data (void)
 {
     return m_begin;
@@ -84,7 +84,7 @@ linear::data (void)
 
 
 //-----------------------------------------------------------------------------
-const void*
+const std::byte*
 linear::data (void) const
 {
     return m_begin;
@@ -92,7 +92,7 @@ linear::data (void) const
 
 
 //-----------------------------------------------------------------------------
-void*
+std::byte*
 linear::begin (void)
 {
     return m_begin;
@@ -100,18 +100,34 @@ linear::begin (void)
 
 
 //-----------------------------------------------------------------------------
-const void*
+const std::byte*
 linear::begin (void) const
 {
     return m_begin;
 }
 
 
+//-----------------------------------------------------------------------------
+std::byte*
+linear::end (void)
+{
+    return m_end;
+}
+
+
+//-----------------------------------------------------------------------------
+const std::byte*
+linear::end (void) const
+{
+    return m_end;
+}
+
+
 //-----------------------------------------------------------------------------
 size_t
 linear::offset (const void *_ptr) const
 {
-    auto ptr = reinterpret_cast<const char*> (_ptr);
+    auto ptr = reinterpret_cast<const std::byte*> (_ptr);
 
     CHECK_GE (ptr, m_begin);
     return ptr - m_begin;

alloc/raw/linear.hpp

@@ -43,15 +43,15 @@ namespace util::alloc::raw {
         void  deallocate (void *ptr, size_t bytes);
         void  deallocate (void *ptr, size_t bytes, size_t alignment);
 
-        void* data (void);
+        std::byte* data (void);
-        void* begin (void);
+        std::byte* begin (void);
-        void* end (void);
+        std::byte* end (void);
-        void* cursor (void);
+        std::byte* cursor (void);
 
-        const void* data (void) const;
+        const std::byte* data (void) const;
-        const void* begin (void) const;
+        const std::byte* begin (void) const;
-        const void* end (void) const;
+        const std::byte* end (void) const;
-        const void* cursor (void) const;
+        const std::byte* cursor (void) const;
 
         size_t offset (const void*) const;
 
@@ -62,7 +62,9 @@ namespace util::alloc::raw {
         size_t remain   (void) const;
 
     protected:
-        char *m_begin, *m_end, *m_cursor;
+        std::byte *const m_begin;
+        std::byte *const m_end;
+        std::byte *m_cursor;
     };
 }
 

alloc/raw/null.cpp

@@ -67,7 +67,7 @@ null::deallocate (void *ptr, size_t bytes, size_t align)
 
 
 ///////////////////////////////////////////////////////////////////////////////
-void*
+std::byte*
 null::begin (void)
 {
     return nullptr;
@@ -75,13 +75,25 @@ null::begin (void)
 
 
 //-----------------------------------------------------------------------------
-const void*
+const std::byte*
 null::begin (void) const
 {
     return nullptr;
 }
 
 
+//-----------------------------------------------------------------------------
+std::byte*
+null::end (void)
+{ return nullptr; }
+
+
+//-----------------------------------------------------------------------------
+const std::byte*
+null::end (void) const
+{ return nullptr; }
+
+
 //-----------------------------------------------------------------------------
 size_t
 null::offset (const void *ptr) const

alloc/raw/null.hpp

@@ -17,6 +17,8 @@
 #ifndef CRUFT_UTIL_ALLOC_RAW_NULL_HPP
 #define CRUFT_UTIL_ALLOC_RAW_NULL_HPP
 
+#include "../../view.hpp"
+
 #include <cstddef>
 
 
@@ -35,8 +37,14 @@ namespace util::alloc::raw {
         void deallocate (void *ptr, size_t bytes);
         void deallocate (void *ptr, size_t bytes, size_t align);
 
-        void* begin (void);
+        util::view<std::byte*> data (void);
-        const void* begin (void) const;
+        util::view<const std::byte*> data (void) const;
+
+        std::byte* begin (void);
+        const std::byte* begin (void) const;
+        std::byte* end (void);
+        const std::byte* end (void) const;
+
         size_t offset (const void*) const;
 
         void reset (void);

alloc/raw/stack.cpp

@@ -25,9 +25,9 @@ using util::alloc::raw::stack;
 
 ///////////////////////////////////////////////////////////////////////////////
 stack::stack (void *begin, void *end):
-    m_begin  (reinterpret_cast<char*> (begin)),
+    m_begin  (reinterpret_cast<std::byte*> (begin)),
-    m_end    (reinterpret_cast<char*> (end)),
+    m_end    (reinterpret_cast<std::byte*> (end)),
-    m_cursor (reinterpret_cast<char*> (begin))
+    m_cursor (m_begin)
 {
     CHECK_LE (m_begin, m_end);
 }
@@ -37,8 +37,8 @@ stack::stack (void *begin, void *end):
 union record {
     using offset_t = uint32_t;
 
-    char     *as_bytes;
+    std::byte *as_bytes;
-    offset_t *as_offset;
+    offset_t  *as_offset;
 };
 
 
@@ -100,7 +100,7 @@ stack::deallocate (void *_ptr, size_t bytes, size_t alignment)
     (void)alignment;
     //alignment = util::max (MIN_ALIGNMENT, alignment);
     
-    auto ptr = reinterpret_cast<char*> (_ptr);
+    auto ptr = reinterpret_cast<std::byte*> (_ptr);
 
     record record;
     record.as_bytes = ptr - sizeof (record::offset_t);
@@ -114,7 +114,7 @@ stack::deallocate (void *_ptr, size_t bytes, size_t alignment)
 
 
 //-----------------------------------------------------------------------------
-void*
+std::byte*
 stack::begin (void)
 {
     return m_begin;
@@ -122,7 +122,7 @@ stack::begin (void)
 
 
 //-----------------------------------------------------------------------------
-const void*
+const std::byte*
 stack::begin (void) const
 {
     return m_begin;
@@ -133,7 +133,7 @@ stack::begin (void) const
 size_t
 stack::offset (const void *_ptr) const
 {
-    auto ptr = reinterpret_cast<const char*> (_ptr);
+    auto ptr = reinterpret_cast<const std::byte*> (_ptr);
 
     CHECK_GE (ptr, m_begin);
     return ptr - m_begin;

alloc/raw/stack.hpp

@@ -17,6 +17,8 @@
 #ifndef CRUFT_UTIL_ALLOC_RAW_STACK_HPP
 #define CRUFT_UTIL_ALLOC_RAW_STACK_HPP
 
+#include "../../view.hpp"
+
 #include <cstddef>
 
 
@@ -38,8 +40,15 @@ namespace util::alloc::raw {
         void deallocate (void *ptr, size_t bytes);
         void deallocate (void *ptr, size_t bytes, size_t alignment);
 
-        void* begin (void);
+        util::view<std::byte*> data (void);
-        const void* begin (void) const;
+        util::view<const std::byte*> data (void) const;
+
+        std::byte* begin (void);
+        const std::byte* begin (void) const;
+
+        std::byte* end (void);
+        const std::byte* end (void) const;
+
         size_t offset (const void*) const;
 
         void reset (void);
@@ -49,7 +58,9 @@ namespace util::alloc::raw {
         size_t remain   (void) const;
 
     private:
-        char *m_begin, *m_end, *m_cursor;
+        std::byte *const m_begin;
+        std::byte *const m_end;
+        std::byte *m_cursor;
     };
 }
 

test/alloc/linear.cpp

@@ -10,7 +10,7 @@ main (void)
 
     constexpr size_t BUFFER_SIZE = 1024;
 
-    alignas (std::max_align_t) char memory[BUFFER_SIZE];
+    alignas (std::max_align_t) std::byte memory[BUFFER_SIZE];
     util::alloc::raw::linear store (std::begin (memory), std::end (memory));
 
     tap.expect_eq (store.begin (), std::begin (memory), "base pointers match");

test/alloc/stack.cpp

@@ -29,8 +29,8 @@ main (void)
 
     // alignment is kinda important, so make it a little easier and ensure
     // something suitable right off the bat.
-    alignas (std::max_align_t) char memory[BUFFER_SIZE];
+    alignas (std::max_align_t) std::byte memory[BUFFER_SIZE];
-    std::fill (std::begin (memory), std::end (memory), 0);
+    std::fill (std::begin (memory), std::end (memory), std::byte{0});
 
     util::alloc::raw::stack store (memory, memory + BUFFER_AVAILABLE);