Code refactoring

Author: vitalsong

include/dsplib/slice.h

@@ -108,35 +108,7 @@ class mut_slice_t
     }
 
     mut_slice_t& operator=(const slice_t<T>& rhs) {
-        DSPLIB_ASSERT(this->size() == rhs.size(), "Slices size must be equal");
-        const int count = this->size();
-
-        //empty slice assign
-        if (count == 0) {
-            return *this;
-        }
-
-        //simple block copy/move (optimization)
-        const bool is_same = is_same_memory(rhs, slice_t(*this));
-        if ((this->stride() == 1) && (rhs.stride() == 1)) {
-            const auto* src = &(*rhs.begin());
-            auto* dst = &(*begin());
-            if (!is_same) {
-                std::memcpy(dst, src, count * sizeof(*src));
-            } else {
-                //overlapped
-                std::memmove(dst, src, count * sizeof(*src));
-            }
-            return *this;
-        }
-
-        //same array, specific indexing
-        if (is_same) {
-            *this = base_array<T>(rhs);
-            return *this;
-        }
-
-        std::copy(rhs.begin(), rhs.end(), this->begin());
+        this->copy(*this, rhs);
         return *this;
     }
 
@@ -218,6 +190,38 @@ class mut_slice_t
         return mut_slice_t(data + i1, step, count);
     }
 
+    static void copy(mut_slice_t<T> lhs, slice_t<T> rhs) {
+        DSPLIB_ASSERT(lhs.size() == rhs.size(), "Slices size must be equal");
+        const int count = lhs.size();
+
+        //empty slice assign
+        if (count == 0) {
+            return;
+        }
+
+        //simple block copy/move (optimization)
+        const bool is_same = is_same_memory(rhs, slice_t(lhs));
+        if ((lhs.stride() == 1) && (rhs.stride() == 1)) {
+            const auto* src = &(*rhs.begin());
+            auto* dst = &(*lhs.begin());
+            if (!is_same) {
+                std::memcpy(dst, src, count * sizeof(*src));
+            } else {
+                //overlapped
+                std::memmove(dst, src, count * sizeof(*src));
+            }
+            return;
+        }
+
+        //same array, specific indexing
+        if (is_same) {
+            lhs = base_array<T>(rhs);
+            return;
+        }
+
+        std::copy(rhs.begin(), rhs.end(), lhs.begin());
+    }
+
 protected:
     explicit mut_slice_t(T* data, int stride, int count)
       : data_{data}

include/dsplib/span.h

@@ -64,8 +64,6 @@ class mut_span_t : public mut_slice_t<T>
         return this->data_[i];
     }
 
-    //TODO: override fast implementation for span
-
     mut_span_t& operator=(const mut_span_t& rhs) {
         if (this == &rhs) {
             return *this;
@@ -74,14 +72,13 @@ class mut_span_t : public mut_slice_t<T>
         return *this;
     }
 
+    //TODO: override fast implementation for span
     mut_span_t& operator=(const slice_t<T>& rhs) {
-        //TODO: check if slice ~ span (but check overlap memory)
         mut_slice_t<T>::operator=(rhs);
         return *this;
     }
 
     mut_span_t& operator=(const mut_slice_t<T>& rhs) {
-        //TODO: check if slice ~ span
         mut_slice_t<T>::operator=(rhs);
         return *this;
     }
@@ -216,7 +213,6 @@ mut_span_t<T> make_span(base_array<T>& x) noexcept {
     return mut_span_t<T>(x.data(), x.size());
 }
 
-//TODO: short naming, span_r/span_c?
 using span_real = span_t<real_t>;
 using span_cmplx = span_t<cmplx_t>;