chagne the implementation of vtr::vector::pairs()

Author: soheilshahrouz

libs/libvtrutil/src/vtr_vector.h

@@ -56,9 +56,6 @@ class vector : private std::vector<V, Allocator> {
     class key_iterator;
     typedef vtr::Range<key_iterator> key_range;
 
-    class pair_iterator;
-    typedef vtr::Range<pair_iterator> pair_range;
-
   public:
     //Pass through std::vector's types
     using typename storage::allocator_type;
@@ -157,16 +154,31 @@ class vector : private std::vector<V, Allocator> {
     }
 
     /**
-     * @brief Returns a range containing the key-value pairs.
+     * @brief Provides an iterable object to enumerate the vector.
      *
-     * This function returns a range object that represents the sequence of key-value
-     * pairs within the vector. The range can be used to iterate over the pairs using
-     * standard range-based loops or algorithms.
+     * This function allows for easy enumeration, yielding a tuple of (index, element)
+     * pairs in each iteration. It is similar in functionality to Python's `enumerate()`.
      *
-     * @return A `pair_range` object representing the range of key-value pairs.
+     * @ return An iterable wrapper that can be used in a range-based for loop to obtain
+     * (index, element) pairs.
      */
-    pair_range pairs() const {
-        return vtr::make_range(pair_begin(), pair_end());
+    auto pairs() const {
+        struct enumerated_iterator {
+            key_type i;
+            vector::const_iterator iter;
+
+            bool operator!=(const enumerated_iterator& other) const { return iter != other.iter; }
+            void operator++() { i = key_type(size_t(i) + 1); iter++; }
+            std::tuple<key_type, decltype(*iter)&> operator*() { return std::tie(i, *iter); }
+        };
+
+        struct enumerated_wrapper {
+            const vector& vec;
+            auto begin() { return enumerated_iterator{ key_type(0), vec.begin() }; }
+            auto end() { return enumerated_iterator{ key_type(vec.size()), vec.end() }; }
+        };
+
+        return enumerated_wrapper{ *this };
     }
 
   public:
@@ -218,59 +230,9 @@ class vector : private std::vector<V, Allocator> {
         value_type value_;
     };
 
-        /**
-         * @brief A bidirectional iterator for a vtr:vector object.
-         *
-         * The `pair_iterator` class provides a way to iterate over key-value pairs
-         * within a vtr::vector container. It supports bidirectional iteration,
-         * allowing the user to traverse the container both forwards and backwards.
-         */
-        class pair_iterator {
-          public:
-            using iterator_category = std::bidirectional_iterator_tag;
-            using difference_type = std::ptrdiff_t;
-            using value_type = std::pair<key_type, V>;
-            using pointer = value_type*;
-            using reference = value_type&;
-
-            /// @brief constructor
-            pair_iterator(vector<K, V, Allocator>& vec, key_type init)
-                : vec_(vec), value_(init, vec[init]) {}
-
-            /// @brief ++ operator
-            pair_iterator& operator++() {
-                value_ = std::make_pair(key_type(size_t(value_.first) + 1), vec_[key_type(size_t(value_.first) + 1)]);
-                return *this;
-            }
-            /// @brief -- operator
-            pair_iterator& operator--() {
-                value_ = std::make_pair(key_type(size_t(value_.first) - 1), vec_[key_type(size_t(value_.first) - 1)]);
-                return *this;
-            }
-            /// @brief dereference operator
-            reference operator*() { return value_; }
-            /// @brief -> operator
-            pointer operator->() { return &value_; }
-
-            /// @brief == operator
-            friend bool operator==(const pair_iterator& lhs, const pair_iterator& rhs) { return lhs.value_.first == rhs.value_.first; }
-            /// @brief != operator
-            friend bool operator!=(const pair_iterator& lhs, const pair_iterator& rhs) { return !(lhs == rhs); }
-
-          private:
-            /// @brief Reference to the vector of key-value pairs.
-            vector<K, V, Allocator>& vec_;
-            // @brief The current key-value pair being pointed to by the iterator.
-            value_type value_;
-        };
-
   private:
     key_iterator key_begin() const { return key_iterator(key_type(0)); }
     key_iterator key_end() const { return key_iterator(key_type(size())); }
-
-    pair_iterator pair_begin() const { return pair_iterator(*const_cast<vector<K, V, Allocator>*>(this), key_type(0)); }
-    pair_iterator pair_end() const { return pair_iterator(*const_cast<vector<K, V, Allocator>*>(this), key_type(size())); }
 };
-
 } // namespace vtr
 #endif

vpr/test/test_odd_even_routing.cpp

@@ -226,7 +226,7 @@ TEST_CASE("test_route_flow", "[vpr_noc_odd_even_routing]") {
         compare_routes(golden_path, found_path, noc_model);
     }
 
-    SECTION("Test case where multiple traffic flows are router, and routes are checked for turn legality and deadlock freedom.") {
+    SECTION("Test case where multiple traffic flows are routed, and routes are checked for turn legality and deadlock freedom.") {
         std::random_device device;
         std::mt19937 rand_num_gen(device());
         std::uniform_int_distribution<std::mt19937::result_type> dist(0,  99);