Move glcr::Array & glcr::ArrayView loops to range-based.

lib/glacier/container/array.h

@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 
+#include "glacier/container/array_iter.h"
 #include "glacier/container/array_view.h"
 
 namespace glcr {
@@ -37,6 +38,13 @@ class Array {
   uint64_t size() const { return size_; }
   bool empty() const { return size_ == 0; }
 
+  typedef ArrayIterator<T> Iterator;
+
+  Iterator begin() { return {data_, size_}; }
+  const Iterator begin() const { return {data_, size_}; }
+  Iterator end() { return {nullptr, 0}; }
+  const Iterator end() const { return {nullptr, 0}; }
+
  private:
   T* data_;
   uint64_t size_;

lib/glacier/container/array_iter.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace glcr {
+
+template <typename T>
+class ArrayIterator {
+ public:
+  ArrayIterator(T* item, uint64_t size) : item_(item), size_(size) {}
+
+  ArrayIterator next() {
+    if (size_ <= 1) {
+      return {nullptr, 0};
+    }
+    return {item_ + 1, size_ - 1};
+  }
+
+  ArrayIterator& operator++() {
+    if (size_ <= 1) {
+      item_ = nullptr;
+      size_ = 0;
+    } else {
+      item_++;
+      size_--;
+    }
+    return *this;
+  }
+
+  T& operator*() { return *item_; }
+  T* operator->() { return item_; }
+  bool operator==(const ArrayIterator& other) { return item_ == other.item_; }
+  bool operator!=(const ArrayIterator& other) { return item_ != other.item_; }
+
+ private:
+  T* item_;
+  uint64_t size_;
+};
+
+}  // namespace glcr

lib/glacier/container/array_view.h

@@ -2,6 +2,8 @@
 
 #include <stdint.h>
 
+#include "glacier/container/array_iter.h"
+
 namespace glcr {
 
 template <typename T>
@@ -26,6 +28,23 @@ class ArrayView {
   uint64_t size() const { return size_; }
   bool empty() const { return size_; }
 
+  typedef ArrayIterator<T> Iterator;
+
+  Iterator begin() {
+    if (size_ == 0) {
+      return {nullptr, 0};
+    }
+    return {data_, size_};
+  }
+  const Iterator begin() const {
+    if (size_ == 0) {
+      return {nullptr, 0};
+    }
+    return {data_, size_};
+  }
+  Iterator end() { return {nullptr, 0}; }
+  const Iterator end() const { return {nullptr, 0}; }
+
  private:
   T* data_;
   uint64_t size_;

lib/glacier/container/hash_map.h

@@ -194,8 +194,7 @@ template <typename K, typename V, class H>
 void HashMap<K, V, H>::Resize(uint64_t new_size) {
   Array<LinkedList<Pair<K, V>>> new_data(new_size);
 
-  for (uint64_t i = 0; i < data_.size(); i++) {
+  for (auto& ll : data_) {
-    auto& ll = data_[i];
     while (!ll.empty()) {
       auto pair = ll.PopFront();
       uint64_t hc = H()(pair.first());

lib/glacier/container/vector.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <glacier/container/array_iter.h>
 #include <glacier/memory/move.h>
 #include <stdint.h>
 
@@ -48,38 +49,7 @@ class Vector {
 
   T&& PopBack();
 
-  // Forward Iter
+  typedef ArrayIterator<T> Iterator;
-  class Iterator {
-   public:
-    Iterator(T* item, uint64_t size) : item_(item), size_(size) {}
-
-    Iterator next() {
-      if (size_ <= 1) {
-        return {nullptr, 0};
-      }
-      return {item_ + 1, size_ - 1};
-    }
-
-    Iterator& operator++() {
-      if (size_ <= 1) {
-        item_ = nullptr;
-        size_ = 0;
-      } else {
-        item_++;
-        size_--;
-      }
-      return *this;
-    }
-
-    T& operator*() { return *item_; }
-    T* operator->() { return item_; }
-    bool operator==(const Iterator& other) { return item_ == other.item_; }
-    bool operator!=(const Iterator& other) { return item_ != other.item_; }
-
-   private:
-    T* item_;
-    uint64_t size_;
-  };
 
   Iterator begin() { return {data_, size_}; }
   const Iterator begin() const { return {data_, size_}; }

zion/object/memory_object.cpp

@@ -47,16 +47,16 @@ VariableMemoryObject::VariableMemoryObject(uint64_t size) : size_(size) {
   // FIXME: Do this lazily.
   uint64_t num_pages = size_ / 0x1000;
   phys_page_list_ = glcr::Array<uint64_t>(num_pages);
-  for (uint64_t i = 0; i < phys_page_list_.size(); i++) {
+  for (uint64_t& page : phys_page_list_) {
-    phys_page_list_[i] = 0;
+    page = 0;
   }
 }
 
 VariableMemoryObject::~VariableMemoryObject() {
-  for (uint64_t p = 0; p < phys_page_list_.size(); p++) {
+  for (uint64_t& page : phys_page_list_) {
-    if (phys_page_list_[p] != 0) {
+    if (page != 0) {
       // TODO: We may be able to do some sort of coalescing here.
-      phys_mem::FreePage(phys_page_list_[p]);
+      phys_mem::FreePage(page);
     }
   }
 }

zion/syscall/ipc.cpp

@@ -28,12 +28,12 @@ glcr::ErrorOr<IpcMessage> TranslateRequestToIpcMessage(const T& req) {
   glcr::ArrayView<const z_cap_t> caps(req.caps, req.num_caps);
 
   message.caps.Resize(caps.size());
-  for (uint64_t i = 0; i < caps.size(); i++) {
+  for (uint64_t capid : caps) {
     // FIXME: This would feel safer closer to the relevant syscall.
     // FIXME: Race conditions on get->check->release here. Would be better to
     // have that as a single call on the process. (This pattern repeats other
     // places too).
-    auto cap = gScheduler->CurrentProcess().GetCapability(caps[i]);
+    auto cap = gScheduler->CurrentProcess().GetCapability(capid);
     if (!cap) {
       return glcr::CAP_NOT_FOUND;
     }
@@ -41,7 +41,7 @@ glcr::ErrorOr<IpcMessage> TranslateRequestToIpcMessage(const T& req) {
       return glcr::CAP_PERMISSION_DENIED;
     }
     message.caps.PushBack(
-        gScheduler->CurrentProcess().ReleaseCapability(caps[i]));
+        gScheduler->CurrentProcess().ReleaseCapability(capid));
   }
 
   return message;