initial sort support + cleanups

octa/algorithm.h

@@ -7,8 +7,37 @@
 #define OCTA_ALGORITHM_H
 
 #include "octa/functional.h"
+#include "octa/range.h"
 
 namespace octa {
+    template<typename R, typename C>
+    void insertion_sort(R range, C compare) {
+        size_t rlen = range.length();
+        for (size_t i = 1; i < rlen; ++i) {
+            size_t j = i, v = range[i];
+            while (j > 0 && !compare(range[j - 1], v)) {
+                range[j] = range[j - 1];
+                --j;
+            }
+            range[j] = v;
+        }
+    }
+
+    template<typename R>
+    void insertion_sort(R range) {
+        insertion_sort(range, Less<typename RangeTraits<R>::value>());
+    }
+
+
+    template<typename R, typename C>
+    void sort(R range, C compare) {
+        insertion_sort(range, compare);
+    }
+
+    template<typename R>
+    void sort(R range) {
+        sort(range, Less<typename RangeTraits<R>::value>());
+    }
 }
 
 #endif

octa/vector.h

@@ -74,10 +74,7 @@ namespace octa {
             if (p_len + n > p_cap) reserve(p_len + n);
             p_len += n;
             for (size_t i = p_len - 1; i > idx + n - 1; --i) {
-                if (octa::IsClass<T>::value && i < (p_len - n)) {
-                    p_buf[i].~T();
-                }
-                new (&p_buf[i]) T(move(p_buf[i - n]));
+                p_buf[i] = move(p_buf[i - n]);
             }
         }
 
@@ -168,6 +165,14 @@ namespace octa {
             return *this;
         }
 
+        Vector<T> &operator=(Vector<T> &&v) {
+            clear();
+            p_len = v.p_len;
+            p_cap = v.p_cap;
+            p_buf = v.disown();
+            return *this;
+        }
+
         void resize(size_t n, const T &v = T()) {
             size_t len = p_len;
             reserve(n);
@@ -278,23 +283,20 @@ namespace octa {
 
         T *insert(size_t idx, T &&v) {
             insert_base(idx, 1);
-            p_buf[idx].~T();
-            new (&p_buf[idx]) T(forward<T>(v));
+            p_buf[idx] = forward<T>(v);
             return &p_buf[idx];
         }
 
         T *insert(size_t idx, const T &v) {
             insert_base(idx, 1);
-            p_buf[idx].~T();
-            new (&p_buf[idx]) T(v);
+            p_buf[idx] = v;
             return &p_buf[idx];
         }
 
         T *insert(size_t idx, size_t n, const T &v) {
             insert_base(idx, n);
             for (size_t i = 0; i < n; ++i) {
-                p_buf[idx + i].~T();
-                new (&p_buf[idx + i]) T(v);
+                p_buf[idx + i] = v;
             }
             return &p_buf[idx];
         }
@@ -304,8 +306,7 @@ namespace octa {
             size_t len = range.length();
             insert_base(idx, len);
             for (size_t i = 0; i < len; ++i) {
-                p_buf[idx + i].~T();
-                new (&p_buf[idx + i]) T(range.first());
+                p_buf[idx + i] = range.first();
                 range.pop_first();
             }
             return &p_buf[idx];