fcccode
diff --git a/‎slice.hpp‎
Lines changed: 25 additions & 27 deletions b/‎slice.hpp‎
Lines changed: 25 additions & 27 deletions
@@ -15,7 +15,7 @@ namespace iter {
     //class Slice;
 
     //template <typename T>
-    //Slice<std::initializer_list<T>> slice( std::initializer_list<T> &&);
+    //Slice<std::initializer_list<T>> slice( std::initializer_list<T>);
 
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
@@ -33,19 +33,19 @@ namespace iter {
         enum { value = sizeof(test<T>(0)) == sizeof(char) };
     };
     template <typename Container>
-    typename std::enable_if<has_size<Container>::value,size_t>::type 
-    size(Container & container) {
+    typename std::enable_if<has_size<Container>::value, std::size_t>::type 
+    size(const Container& container) {
         return container.size();
     }
 
     template <typename Container>
-    typename std::enable_if<!has_size<Container>::value,size_t>::type 
-    size(Container & container) {
+    typename std::enable_if<!has_size<Container>::value, std::size_t>::type 
+    size(const Container& container) {
         return std::distance(std::begin(container), std::end(container));
     }
 
-    template <typename T, size_t N>
-    size_t size(T (&)[N]) {
+    template <typename T, std::size_t N>
+    std::size_t size(const T (&)[N]) {
         return N;
     }
 
@@ -54,7 +54,7 @@ namespace iter {
     template <typename Container, typename DifferenceType>
     class Slice {
         private:
-            Container & container;
+            Container container;
             DifferenceType start;
             DifferenceType stop;
             DifferenceType step;
@@ -63,17 +63,11 @@ namespace iter {
             // the slice function
             //friend Slice slice<Container, DifferenceType>(Container &&);
             //template <typename T>
-            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T> &&);
-
-            
-
-            
-
-            
+            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T>);
         public:
-            Slice(Container & container, DifferenceType start,
+            Slice(Container in_container, DifferenceType start,
                   DifferenceType stop, DifferenceType step)
-                : container{container},
+                : container(std::forward<Container>(in_container)),
                 start{start},
                 stop{stop},
                 step{step}
@@ -83,16 +77,20 @@ namespace iter {
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
-                if (this->stop > static_cast<DifferenceType>(size(container))) {
-                    this->stop = static_cast<DifferenceType>(size(container));
+                if (this->stop > static_cast<DifferenceType>(
+                            size(this->container))) {
+                    this->stop = static_cast<DifferenceType>(size(
+                                this->container));
+                    std::cout << "stop is too large\n";
+                    std::cout << "stop is now: " << this->stop << '\n';
                 }
                 if (this->start < 0) {
                     this->start = 0; 
                 }
             }
 
-            Slice () = delete;
-            Slice & operator=(const Slice &) = delete;
+            Slice() = delete;
+            Slice& operator=(const Slice&) = delete;
 
             Slice(const Slice &) = default;
 
@@ -117,7 +115,7 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         std::advance(this->sub_iter, this->step);
                         this->current += this->step;
                         return *this;
@@ -144,28 +142,28 @@ namespace iter {
     // Helper function to instantiate a Slice
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
-            Container && container, DifferenceType start,
-            DifferenceType stop, DifferenceType step=1) {
+            Container&& container,
+            DifferenceType start, DifferenceType stop, DifferenceType step=1) {
         return {std::forward<Container>(container), start, stop, step};
     }
 
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
-            Container && container, DifferenceType stop) {
+            Container&& container, DifferenceType stop) {
         return {std::forward<Container>(container), 0, stop, 1};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> && il, DifferenceType start,
+            std::initializer_list<T> il, DifferenceType start,
             DifferenceType stop, DifferenceType step=1) {
         return {il, start, stop, step};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> && il, DifferenceType stop) {
+            std::initializer_list<T> il, DifferenceType stop) {
         return {il, 0, stop, 1};
     }
 }