LinkedList: Simplify and standardize

Template on the predicate functions to avoid std::function overhead,
and clean up the looping logic.

Author: willmmiles

src/StringArray.h

@@ -40,7 +40,6 @@ class LinkedList {
   public:
     typedef Item<T> ItemType;
     typedef std::function<void(const T&)> OnRemove;
-    typedef std::function<bool(const T&)> Predicate;
   private:
     ItemType* _root;
     ItemType* _last;    
@@ -87,6 +86,7 @@ class LinkedList {
 
     LinkedList(OnRemove onRemove) : _root(nullptr), _last(nullptr), _onRemove(onRemove) {}
     ~LinkedList() { free(); }
+
     void add(T t){
       auto it = new ItemType(std::move(t));
       if(!_root){
@@ -97,91 +97,84 @@ class LinkedList {
       }
       _last = it;
     }
+
     T& front() const {
       return _root->value();
     }
 
     bool isEmpty() const {
       return _root == nullptr;
     }
+
     size_t length() const {
       size_t i = 0;
-      auto it = _root;
-      while(it){
-        i++;
-        it = it->next;
-      }
+      for(auto it = _root; it != nullptr; it = it->next) { ++i; };
       return i;
     }
-    size_t count_if(Predicate predicate) const {
+
+    template<typename Predicate>
+    size_t count_if(const Predicate& predicate) const {
       size_t i = 0;
-      auto it = _root;
-      while(it){
-        if (!predicate){
-          i++;
-        }
-        else if (predicate(it->value())) {
+      for(auto it = _root; it != nullptr; it = it->next) {
+        if (predicate(it->value())) {
           i++;
         }
-        it = it->next;
       }
       return i;
     }
+
     const T* nth(size_t N) const {
       size_t i = 0;
-      auto it = _root;
-      while(it){
-        if(i++ == N)
-          return &(it->value());
-        it = it->next;
-      }
+      for(auto it = _root; it != nullptr; it = it->next) {
+        if(i++ == N) return &(it->value());              
+      };
       return nullptr;
     }
+
     bool remove(const T& t){
-      auto it = _root;
-      auto pit = decltype(it) { nullptr };
-      while(it){
+      auto pit = (ItemType*) nullptr;
+      for(auto it = _root; it != nullptr; pit = it, it = it->next) {
         if(it->value() == t){
           _remove(pit, it);
           return true;
         }
-        pit = it;
-        it = it->next;
       }
       return false;
     }
-    bool remove_first(Predicate predicate){
-      auto it = _root;
-      auto pit = decltype(it) { nullptr };
-      while(it){
+    
+    template<typename Predicate>
+    bool remove_first(const Predicate& predicate){
+      auto pit = (ItemType*) nullptr;
+      for(auto it = _root; it != nullptr; pit = it, it = it->next) {
         if(predicate(it->value())){
           _remove(pit, it);
           return true;
         }
-        pit = it;
-        it = it->next;
       }
       return false;
     }
-    bool remove(const ConstIterator& t, const ConstIterator& where = ConstIterator(nullptr)) {
+
+    bool remove(const ConstIterator& t, const ConstIterator& where) {
       if (where._node) {
         if ((where._node->next) != t._node) return false;
         _remove(where._node, t._node);
         return true;
+      } else {
+        return remove(t);
       }
+    }
 
-      auto it = _root;
-      auto pit = decltype(it) { nullptr };
-      while(it){
+    bool remove(const ConstIterator& t) {
+      auto pit = (ItemType*) nullptr;
+      for(auto it = _root; it != nullptr; pit = it, it = it->next) {
         if(it == t._node){
           _remove(pit, it);
           return true;
         }
-        pit = it;
-        it = it->next;
       }
       return false;      
-    }    
+    }
+
     void free(){
       while(_root != nullptr){
         auto it = _root;