src: improve TSList iteration and erase operations

Add a size-aware for_each overload to TSList so callbacks can observe
the list size while iterating. Return the updated size from erase and
extend coverage for object and pointer specializations.

Signed-off-by: Santiago Gimeno <santiago.gimeno@gmail.com>
PR-URL: #517
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: santigimeno

src/nsolid/thread_safe.h

@@ -158,9 +158,17 @@ struct TSList {
     nsuv::ns_mutex::scoped_lock lock(lock_);
     std::for_each(list_.begin(), list_.end(), fn);
   }
-  inline void erase(iterator it) {
+  inline void for_each(std::function<void(const DataType&, size_t)> fn) {
+    nsuv::ns_mutex::scoped_lock lock(lock_);
+    size_t current_size = list_.size();
+    for (auto& item : list_) {
+      fn(item, current_size);
+    }
+  }
+  inline size_t erase(iterator it) {
     nsuv::ns_mutex::scoped_lock lock(lock_);
     list_.erase(it);
+    return list_.size();
   }
   inline size_t size() {
     nsuv::ns_mutex::scoped_lock lock(lock_);
@@ -190,9 +198,17 @@ struct TSList<DataType*> {
     nsuv::ns_mutex::scoped_lock lock(lock_);
     std::for_each(list_.begin(), list_.end(), fn);
   }
-  inline void erase(iterator it) {
+  inline void for_each(std::function<void(DataType*, size_t)> fn) {
+    nsuv::ns_mutex::scoped_lock lock(lock_);
+    size_t current_size = list_.size();
+    for (auto& item : list_) {
+      fn(item, current_size);
+    }
+  }
+  inline size_t erase(iterator it) {
     nsuv::ns_mutex::scoped_lock lock(lock_);
     list_.erase(it);
+    return list_.size();
   }
   inline size_t size() {
     nsuv::ns_mutex::scoped_lock lock(lock_);

test/cctest/test_nsolid_thread_safe.cc

@@ -50,6 +50,86 @@ TEST(TSListTest, ObjectIterator) {
   });
 }
 
+// Test TSList::for_each with size parameter (object specialization)
+TEST(TSListTest, ObjectForEachWithSize) {
+  TSList<int> list;
+  list.push_back(10);
+  list.push_back(20);
+  list.push_back(30);
+  std::vector<int> values;
+  std::vector<size_t> sizes;
+  list.for_each([&](const int& v, size_t size) {
+    values.push_back(v);
+    sizes.push_back(size);
+  });
+  EXPECT_EQ(values.size(), 3u);
+  EXPECT_EQ(sizes[0], 3u);
+  EXPECT_EQ(sizes[1], 3u);
+  EXPECT_EQ(sizes[2], 3u);
+  EXPECT_EQ(values[0], 10);
+  EXPECT_EQ(values[1], 20);
+  EXPECT_EQ(values[2], 30);
+}
+
+// Test TSList::erase returns new size (object specialization)
+TEST(TSListTest, ObjectEraseReturnsSize) {
+  TSList<int> list;
+  auto it1 = list.push_back(1);
+  auto it2 = list.push_back(2);
+  auto it3 = list.push_back(3);
+  EXPECT_EQ(list.erase(it2), 2u);
+  EXPECT_EQ(list.erase(it1), 1u);
+  EXPECT_EQ(list.erase(it3), 0u);
+}
+
+// Test TSList::for_each with size parameter (pointer specialization)
+TEST(TSListTest, PointerForEachWithSize) {
+  TSList<int*> list;
+  auto it1 = list.push_back(new int(100));
+  auto it2 = list.push_back(new int(200));
+  auto it3 = list.push_back(new int(300));
+  std::vector<int> values;
+  std::vector<size_t> sizes;
+  list.for_each([&](int* v, size_t size) {
+    values.push_back(*v);
+    sizes.push_back(size);
+  });
+  EXPECT_EQ(values.size(), 3u);
+  EXPECT_EQ(sizes[0], 3u);
+  EXPECT_EQ(sizes[1], 3u);
+  EXPECT_EQ(sizes[2], 3u);
+  EXPECT_EQ(values[0], 100);
+  EXPECT_EQ(values[1], 200);
+  EXPECT_EQ(values[2], 300);
+  // Clean up
+  int* tmp = *it1;
+  delete tmp;
+  tmp = *it2;
+  delete tmp;
+  tmp = *it3;
+  delete tmp;
+  list.erase(it1);
+  list.erase(it2);
+  list.erase(it3);
+}
+
+// Test TSList::erase returns new size (pointer specialization)
+TEST(TSListTest, PointerEraseReturnsSize) {
+  TSList<int*> list;
+  auto it1 = list.push_back(new int(1));
+  auto it2 = list.push_back(new int(2));
+  auto it3 = list.push_back(new int(3));
+  int* p1 = *it1;
+  int* p2 = *it2;
+  int* p3 = *it3;
+  EXPECT_EQ(list.erase(it2), 2u);
+  EXPECT_EQ(list.erase(it1), 1u);
+  EXPECT_EQ(list.erase(it3), 0u);
+  delete p1;
+  delete p2;
+  delete p3;
+}
+
 TEST(TSListTest, PointerIterator) {
   TSList<int*> list;
   auto it1 = list.push_back(new int(1));