WIP: paging and better malloc.

bastl/include/vector

@@ -4,6 +4,7 @@
 #if !defined(BAD_APPLE_OS_VECTOR_INCLUDED)
 #define BAD_APPLE_OS_VECTOR_INCLUDED
 
+#include <algorithm>
 #include <cstddef>
 #include <new>
 #include <stdexcept>
@@ -11,13 +12,13 @@
 
 namespace std
 {
-template<typename T> // TODO: allocator
+template<typename T, typename TAlloc = void> // TODO: allocator
 class vector
 {
 public:
     using value_type = T;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
     using reference = value_type&;
     using const_reference = const value_type&;
     using pointer = value_type*;
@@ -210,7 +211,7 @@ public:
     constexpr void push_back(value_type&& value)
     {
         reserve(size() + 1);
-        ::new (&_elements[size()]) T(std::move(value));
+        ::new (&_elements[size()]) T(move(value));
         ++_size;
     }
 
@@ -223,7 +224,7 @@ public:
     constexpr reference emplace_back(TArgs&&... args)
     {
         reserve(size() + 1);
-        ::new (&_elements[size()]) T(std::forward<TArgs>(args)...);
+        ::new (&_elements[size()]) T(forward<TArgs>(args)...);
         ++_size;
     }
 
@@ -274,6 +275,27 @@ public:
         }
         _size = newSize;
     }
+
+    constexpr iterator erase(const_iterator first, const_iterator last)
+    {
+        // the spec wants the parameters to be const iterators...
+        iterator realFirst = begin() + (first - begin());
+        iterator realLast = begin() + (last - begin());
+
+        const size_t newSize = size() - (last - first);
+        for (auto it = realLast; it != end(); ++it)
+        {
+            *realFirst = move(*it);
+            ++realFirst;
+        }
+        resize(newSize);
+        return realFirst;
+    }
+
+    constexpr iterator erase(const_iterator pos)
+    {
+        return erase(pos, pos + 1);
+    }
 private:
     void updateCapacity(size_type newCapacity)
     {
@@ -281,6 +303,10 @@ private:
             return;
         }
         T* newElements = static_cast<T*>(malloc(newCapacity * sizeof(T)));
+        if (newElements == nullptr)
+        {
+            __ba_throw bad_alloc();
+        }
         for (size_type idx = 0; idx < size(); ++idx)
         {
             ::new (&newElements[idx]) T(move(_elements[idx]));
@@ -291,6 +317,16 @@ private:
         _capacity = newCapacity;
     }
 };
+
+template<typename T, typename TAlloc, typename Pred>
+constexpr vector<T, TAlloc>::size_type erase_if(vector<T, TAlloc>& vec, Pred pred)
+{
+
+    auto it = remove_if(vec.begin(), vec.end(), pred);
+    auto removed = vec.end() - it;
+    vec.erase(it, vec.end());
+    return removed;
+}
 }
 
 #endif // !defined(BAD_APPLE_OS_VECTOR_INCLUDED)