combine enumerate() and const_enumerate()

Author: luk036

CMakeLists.txt

@@ -9,7 +9,7 @@ option(INSTALL_ONLY "Enable for installation only" OFF)
 # Note: update this to your new project's name and version
 project(
   Py2Cpp
-  VERSION 1.5
+  VERSION 1.5.1
   LANGUAGES CXX
 )
 

include/py2cpp/dict.hpp

@@ -80,6 +80,24 @@ namespace py {
             return this->at(key);
         }
 
+        /**
+         * @brief
+         *
+         * @return auto
+         */
+        auto begin() -> key_iterator<decltype(Base::begin())> {
+            return key_iterator<decltype(Base::begin())>{Base::begin()};
+        }
+
+        /**
+         * @brief
+         *
+         * @return auto
+         */
+        auto end() -> key_iterator<decltype(Base::end())> {
+            return key_iterator<decltype(Base::end())>{Base::end()};
+        }
+
         /**
          * @brief
          *

include/py2cpp/enumerate.hpp

@@ -139,7 +139,7 @@ namespace py {
     }
 
     /**
-     * @brief const_enumerate(const T &iterable)
+     * @brief enumerate(const T &iterable)
      *
      * The `const_enumerate(const T &iterable)` function is a utility function that
      * allows you to iterate over a constant container or range and also get the
@@ -152,9 +152,16 @@ namespace py {
      * @param[in] iterable
      * @return detail::EnumerateIterableWrapper<const T>
      */
-    template <typename T> inline auto const_enumerate(const T &iterable)
+    template <typename T> inline auto enumerate(const T &iterable)
         -> detail::EnumerateIterableWrapper<const T> {
         return detail::EnumerateIterableWrapper<const T>{iterable};
     }
 
+    /**
+     * @brief (deprecated) const_enumerate(const T &iterable)
+     */
+    template <typename T> inline auto const_enumerate(const T &iterable)
+        -> detail::EnumerateIterableWrapper<const T> {
+        return detail::EnumerateIterableWrapper<const T>{iterable};
+    }
 }  // namespace py

include/py2cpp/range.hpp

@@ -18,11 +18,11 @@ namespace py {
      * @tparam T
      */
     template <typename T> struct RangeIterator {
-        using iterator_category = std::output_iterator_tag;
+        using iterator_category = std::input_iterator_tag;
         using difference_type = std::ptrdiff_t;
         using value_type = T;
-        using pointer = T *;                // or also value_type*
-        using reference = T &;              // or also value_type&
+        using pointer = const T *;          // or also value_type*
+        using reference = const T &;        // or also value_type&
         using const_reference = const T &;  // or also value_type&
         using key_type = T;                 // luk:
 
@@ -67,15 +67,6 @@ namespace py {
          */
         CONSTEXPR14 auto operator*() const -> const_reference { return this->i; }
 
-        /**
-         * The `operator*()` function is used to dereference the iterator and return the value it
-         * points to.
-         *
-         * @return The `operator*()` function is returning a reference to the value that the
-         * iterator points to.
-         */
-        CONSTEXPR14 auto operator*() -> reference { return this->i; }
-
         /**
          * @brief
          *

test/source/test_enumerate.cpp

@@ -3,6 +3,7 @@
 #include <py2cpp/enumerate.hpp>  // for enumerate, iterable_wrapper
 #include <py2cpp/range.hpp>      // for range, iterable_wrapper
 #include <utility>               // for pair
+#include <vector>
 
 TEST_CASE("Test enumerate") {
     auto R = py::range(10);
@@ -14,3 +15,25 @@ TEST_CASE("Test enumerate") {
     }
     CHECK(count == R.size());
 }
+
+TEST_CASE("Test enumerate with const vector") {
+    const std::vector<int> V = {10, 20, 30, 40, 50};
+    size_t count = 0;
+    for (const auto &p : py::enumerate(V)) {
+        CHECK(p.first == count);
+        CHECK(p.second == V[count]);
+        ++count;
+    }
+    CHECK(count == V.size());
+}
+
+TEST_CASE("Test enumerate with const vector") {
+    const std::vector<int> V = {10, 20, 30, 40, 50};
+    size_t count = 0;
+    for (const auto &p : py::const_enumerate(V)) {
+        CHECK(p.first == count);
+        CHECK(p.second == V[count]);
+        ++count;
+    }
+    CHECK(count == V.size());
+}