satisfy OutputRange on MoveRange and PointerRange (might be mutable), add more algorithms

octa/algorithm.h

@@ -289,6 +289,36 @@ namespace octa {
         return range2.empty();
     }
 
+    template<typename R1, typename R2>
+    R2 copy(R1 irange, R2 orange) {
+        for (; !irange.empty(); irange.pop_first())
+            orange.put(irange.first());
+        return orange;
+    }
+
+    template<typename R1, typename R2, typename P>
+    R2 copy_if(R1 irange, R2 orange, P pred) {
+        for (; !irange.empty(); irange.pop_first())
+            if (pred(irange.first()))
+                orange.put(irange.first());
+        return orange;
+    }
+
+    template<typename R1, typename R2, typename P>
+    R2 copy_if_not(R1 irange, R2 orange, P pred) {
+        for (; !irange.empty(); irange.pop_first())
+            if (!pred(irange.first()))
+                orange.put(irange.first());
+        return orange;
+    }
+
+    template<typename R1, typename R2>
+    R2 move(R1 irange, R2 orange) {
+        for (; !irange.empty(); irange.pop_first())
+            orange.put(move(irange.first()));
+        return orange;
+    }
+
     template<typename R>
     void reverse(R range) {
         while (!range.empty()) {
@@ -297,6 +327,34 @@ namespace octa {
             range.pop_last();
         }
     }
+
+    template<typename R1, typename R2>
+    R2 reverse_copy(R1 irange, R2 orange) {
+        for (; !irange.empty(); irange.pop_last())
+            orange.put(irange.last());
+        return orange;
+    }
+
+    template<typename R, typename T>
+    void fill(R range, const T &v) {
+        for (; !range.empty(); range.pop_first())
+            range.first() = v;
+    }
+
+    template<typename R, typename F>
+    void generate(R range, F gen) {
+        for (; !range.empty(); range.pop_first())
+            range.first() = gen();
+    }
+
+    template<typename R1, typename R2>
+    R2 swap_ranges(R1 range1, R2 range2) {
+        for (; !range1.empty(); range1.pop_first()) {
+            swap(range1.first(), range2.first());
+            range2.pop_first();
+        }
+        return range2;
+    }
 }
 
 #endif

octa/range.h

@@ -191,6 +191,8 @@ namespace octa {
             return MoveRange<T>(p_range.slice(start, end));
         }
 
+        void put(const typename RangeTraits<T>::value &v) { p_range.put(v); }
+
     private:
         T p_range;
     };
@@ -277,6 +279,9 @@ namespace octa {
               T &operator[](size_t i)       { return p_beg[i]; }
         const T &operator[](size_t i) const { return p_beg[i]; }
 
+        /* satisfy OutputRange */
+        void put(const T &v) { *(p_beg++) = v; }
+
     private:
         T *p_beg, *p_end;
     };

octa/vector.h

@@ -274,7 +274,18 @@ namespace octa {
         typename type::const_range each() const {
             return PointerRange<const T>(p_buf, p_buf + p_len);
         }
+
+        void swap(Vector &v) {
+            swap(p_len, v.p_len);
+            swap(p_cap, v.p_cap);
+            swap(p_buf, v.p_buf);
+        }
     };
+
+    template<typename T>
+    void swap(Vector<T> &a, Vector<T> &b) {
+        a.swap(b);
+    }
 }
 
 #endif