alloc/forwarding: add statically typed forwarding allocator

CMakeLists.txt

@@ -140,6 +140,8 @@ list (
     alloc/allocator.hpp
     alloc/arena.cpp
     alloc/arena.hpp
+    alloc/forwarding.cpp
+    alloc/forwarding.hpp
     alloc/raw/traits.hpp
     alloc/raw/affix.cpp
     alloc/raw/affix.hpp
@@ -430,6 +432,7 @@ if (TESTS)
         alloc/dynamic
         alloc/linear
         alloc/stack
+        alloc/forwarding
         affine
         backtrace
         bezier

alloc/forwarding.cpp

@@ -0,0 +1,17 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2018 Danny Robson <danny@nerdcruft.net>
+ */
+
+#include "forwarding.hpp"

alloc/forwarding.hpp

@@ -0,0 +1,59 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2018 Danny Robson <danny@nerdcruft.net>
+ */
+
+#ifndef CRUFT_UTIL_ALLOC_FORWARDING_HPP
+#define CRUFT_UTIL_ALLOC_FORWARDING_HPP
+
+#include <utility>
+
+namespace util::alloc {
+    template <typename BackingT>
+    class forwarding {
+    public:
+        explicit forwarding (BackingT &backing):
+            m_backing (backing)
+        { ; }
+
+        template <typename ...Args>
+        auto allocate (Args &&...args)
+        {
+            return m_backing.allocate (std::forward<Args> (args)...);
+        }
+
+        template <typename ...Args>
+        auto deallocate (Args &&...args)
+        {
+            return m_backing.deallocate (std::forward<Args> (args)...);
+        }
+
+        auto data  (void) { return m_backing.data ();  }
+        auto begin (void) { return m_backing.begin (); }
+        auto end   (void) { return m_backing.end ();   }
+
+        auto data  (void) const { return m_backing.data ();  }
+        auto begin (void) const { return m_backing.begin (); }
+        auto end   (void) const { return m_backing.end ();   }
+
+        auto capacity (void) const { return m_backing.capacity (); }
+        auto used     (void) const { return m_backing.used (); }
+        auto remain   (void) const { return m_backing.remain (); }
+
+    private:
+        BackingT &m_backing;
+    };
+};
+
+#endif

test/alloc/forwarding.cpp

@@ -0,0 +1,20 @@
+#include "alloc/forwarding.hpp"
+#include "alloc/raw/linear.hpp"
+
+#include "tap.hpp"
+
+
+int
+main ()
+{
+    std::byte buffer[64];
+    util::alloc::raw::linear linear (buffer);
+    util::alloc::forwarding forwarding (linear);
+
+    util::TAP::logger tap;
+    tap.expect_eq (linear.used (), 0u, "construction does not allocate");
+    forwarding.allocate (16u);
+    tap.expect_eq (linear.used (), 16u, "allocation size is exactly committed");
+
+    return tap.status ();
+}