From 823740e1ffa2b3bd39f8dea8062f5c5a0d9c741b Mon Sep 17 00:00:00 2001
From: Daniel Wilhelm <shieldwed@outlook.com>
Date: Thu, 20 Apr 2017 16:55:28 -0600
Subject: normalize most lineendings

---
 zen/fixed_list.h | 478 +++++++++++++++++++++++++++----------------------------
 1 file changed, 239 insertions(+), 239 deletions(-)

(limited to 'zen/fixed_list.h')

diff --git a/zen/fixed_list.h b/zen/fixed_list.h
index e143c7b7..27eb488c 100755
--- a/zen/fixed_list.h
+++ b/zen/fixed_list.h
@@ -1,239 +1,239 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FIXED_LIST_H_01238467085684139453534
-#define FIXED_LIST_H_01238467085684139453534
-
-#include <cassert>
-#include <iterator>
-#include "stl_tools.h"
-
-namespace zen
-{
-//std::list(C++11)-like class for inplace element construction supporting non-copyable/non-movable types
-//-> no iterator invalidation after emplace_back()
-
-template <class T>
-class FixedList
-{
-    struct Node
-    {
-        template <class... Args>
-        Node(Args&& ... args) : val(std::forward<Args>(args)...) {}
-
-        Node* next = nullptr; //singly-linked list is sufficient
-        T val;
-    };
-
-public:
-    FixedList() {}
-
-    ~FixedList() { clear(); }
-
-    template <class NodeT, class U>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, U>
-    {
-    public:
-        FixedIterator(NodeT* it = nullptr) : it_(it) {}
-        FixedIterator& operator++() { it_ = it_->next; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
-        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
-        U& operator* () const { return  it_->val; }
-        U* operator->() const { return &it_->val; }
-    private:
-        NodeT* it_;
-    };
-
-    using value_type      = T;
-    using iterator        = FixedIterator<      Node,       T>;
-    using const_iterator  = FixedIterator<const Node, const T>;
-    using reference       = T&;
-    using const_reference = const T&;
-
-    iterator begin() { return firstInsert_; }
-    iterator end  () { return iterator(); }
-
-    const_iterator begin() const { return firstInsert_; }
-    const_iterator end  () const { return const_iterator(); }
-
-    //const_iterator cbegin() const { return firstInsert_; }
-    //const_iterator cend  () const { return const_iterator(); }
-
-    reference       front()       { return firstInsert_->val; }
-    const_reference front() const { return firstInsert_->val; }
-
-    reference&       back()       { return lastInsert_->val; }
-    const_reference& back() const { return lastInsert_->val; }
-
-    template <class... Args>
-    void emplace_back(Args&& ... args)
-    {
-        Node* newNode = new Node(std::forward<Args>(args)...);
-
-        if (!lastInsert_)
-        {
-            assert(!firstInsert_ && sz_ == 0);
-            firstInsert_ = lastInsert_ = newNode;
-        }
-        else
-        {
-            assert(lastInsert_->next == nullptr);
-            lastInsert_->next = newNode;
-            lastInsert_ = newNode;
-        }
-        ++sz_;
-    }
-
-    template <class Predicate>
-    void remove_if(Predicate pred)
-    {
-        Node* prev = nullptr;
-        Node* ptr = firstInsert_;
-
-        while (ptr)
-            if (pred(ptr->val))
-            {
-                Node* next = ptr->next;
-
-                delete ptr;
-                assert(sz_ > 0);
-                --sz_;
-
-                ptr = next;
-
-                if (prev)
-                    prev->next = next;
-                else
-                    firstInsert_ = next;
-                if (!next)
-                    lastInsert_ = prev;
-            }
-            else
-            {
-                prev = ptr;
-                ptr = ptr->next;
-            }
-    }
-
-    void clear()
-    {
-        Node* ptr = firstInsert_;
-        while (ptr)
-        {
-            Node* next = ptr->next;
-            delete ptr;
-            ptr = next;
-        }
-
-        sz_ = 0;
-        firstInsert_ = lastInsert_ = nullptr;
-    }
-
-    bool empty() const { return sz_ == 0; }
-
-    size_t size() const { return sz_; }
-
-    void swap(FixedList& other)
-    {
-        std::swap(firstInsert_, other.firstInsert_);
-        std::swap(lastInsert_,  other.lastInsert_);
-        std::swap(sz_,          other.sz_);
-    }
-
-private:
-    FixedList           (const FixedList&) = delete;
-    FixedList& operator=(const FixedList&) = delete;
-
-    Node* firstInsert_ = nullptr;
-    Node* lastInsert_  = nullptr; //point to last insertion; required by efficient emplace_back()
-    size_t sz_ = 0;
-};
-
-
-//just as fast as FixedList, but simpler, more CPU-cache-friendly => superseeds FixedList!
-template <class T>
-class FixedVector
-{
-public:
-    FixedVector() {}
-
-    /*
-    class EndIterator {}; //just like FixedList: no iterator invalidation after emplace_back()
-
-    template <class V>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this random-access if needed
-    {
-    public:
-        FixedIterator(std::vector<std::unique_ptr<T>>& cont, size_t pos) : cont_(cont), pos_(pos) {}
-        FixedIterator& operator++() { ++pos_; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, EndIterator) { return lhs.pos_ == lhs.cont_.size(); }
-        inline friend bool operator!=(const FixedIterator& lhs, EndIterator) { return !(lhs == EndIterator()); }
-        V& operator* () const { return  *cont_[pos_]; }
-        V* operator->() const { return &*cont_[pos_]; }
-    private:
-        std::vector<std::unique_ptr<T>>& cont_;
-        size_t pos_ = 0;
-    };
-    */
-
-    template <class IterImpl, class V>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this bidirectional if needed
-    {
-    public:
-        FixedIterator(IterImpl it) : it_(it) {}
-        FixedIterator& operator++() { ++it_; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
-        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
-        V& operator* () const { return  **it_; }
-        V* operator->() const { return &** it_; }
-    private:
-        IterImpl it_;  //TODO: avoid iterator invalidation after emplace_back(); caveat: end() must not store old length!
-    };
-
-    using value_type      = T;
-    using iterator        = FixedIterator<typename std::vector<std::unique_ptr<T>>::iterator,             T>;
-    using const_iterator  = FixedIterator<typename std::vector<std::unique_ptr<T>>::const_iterator, const T>;
-    using reference       =       T&;
-    using const_reference = const T&;
-
-    iterator begin() { return items_.begin(); }
-    iterator end  () { return items_.end  (); }
-
-    const_iterator begin() const { return items_.begin(); }
-    const_iterator end  () const { return items_.end  (); }
-
-    reference       front()       { return *items_.front(); }
-    const_reference front() const { return *items_.front(); }
-
-    reference&       back()       { return *items_.back(); }
-    const_reference& back() const { return *items_.back(); }
-
-    template <class... Args>
-    void emplace_back(Args&& ... args)
-    {
-        items_.push_back(std::make_unique<T>(std::forward<Args>(args)...));
-    }
-
-    template <class Predicate>
-    void remove_if(Predicate pred)
-    {
-        erase_if(items_, [&](const std::unique_ptr<T>& p) { return pred(*p); });
-    }
-
-    void   clear() { items_.clear(); }
-    bool   empty() const { return items_.empty(); }
-    size_t size () const { return items_.size(); }
-    void swap(FixedVector& other) { items_.swap(other.items_); }
-
-private:
-    FixedVector           (const FixedVector&) = delete;
-    FixedVector& operator=(const FixedVector&) = delete;
-
-    std::vector<std::unique_ptr<T>> items_;
-};
-}
-
-#endif //FIXED_LIST_H_01238467085684139453534
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FIXED_LIST_H_01238467085684139453534
+#define FIXED_LIST_H_01238467085684139453534
+
+#include <cassert>
+#include <iterator>
+#include "stl_tools.h"
+
+namespace zen
+{
+//std::list(C++11)-like class for inplace element construction supporting non-copyable/non-movable types
+//-> no iterator invalidation after emplace_back()
+
+template <class T>
+class FixedList
+{
+    struct Node
+    {
+        template <class... Args>
+        Node(Args&& ... args) : val(std::forward<Args>(args)...) {}
+
+        Node* next = nullptr; //singly-linked list is sufficient
+        T val;
+    };
+
+public:
+    FixedList() {}
+
+    ~FixedList() { clear(); }
+
+    template <class NodeT, class U>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, U>
+    {
+    public:
+        FixedIterator(NodeT* it = nullptr) : it_(it) {}
+        FixedIterator& operator++() { it_ = it_->next; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
+        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
+        U& operator* () const { return  it_->val; }
+        U* operator->() const { return &it_->val; }
+    private:
+        NodeT* it_;
+    };
+
+    using value_type      = T;
+    using iterator        = FixedIterator<      Node,       T>;
+    using const_iterator  = FixedIterator<const Node, const T>;
+    using reference       = T&;
+    using const_reference = const T&;
+
+    iterator begin() { return firstInsert_; }
+    iterator end  () { return iterator(); }
+
+    const_iterator begin() const { return firstInsert_; }
+    const_iterator end  () const { return const_iterator(); }
+
+    //const_iterator cbegin() const { return firstInsert_; }
+    //const_iterator cend  () const { return const_iterator(); }
+
+    reference       front()       { return firstInsert_->val; }
+    const_reference front() const { return firstInsert_->val; }
+
+    reference&       back()       { return lastInsert_->val; }
+    const_reference& back() const { return lastInsert_->val; }
+
+    template <class... Args>
+    void emplace_back(Args&& ... args)
+    {
+        Node* newNode = new Node(std::forward<Args>(args)...);
+
+        if (!lastInsert_)
+        {
+            assert(!firstInsert_ && sz_ == 0);
+            firstInsert_ = lastInsert_ = newNode;
+        }
+        else
+        {
+            assert(lastInsert_->next == nullptr);
+            lastInsert_->next = newNode;
+            lastInsert_ = newNode;
+        }
+        ++sz_;
+    }
+
+    template <class Predicate>
+    void remove_if(Predicate pred)
+    {
+        Node* prev = nullptr;
+        Node* ptr = firstInsert_;
+
+        while (ptr)
+            if (pred(ptr->val))
+            {
+                Node* next = ptr->next;
+
+                delete ptr;
+                assert(sz_ > 0);
+                --sz_;
+
+                ptr = next;
+
+                if (prev)
+                    prev->next = next;
+                else
+                    firstInsert_ = next;
+                if (!next)
+                    lastInsert_ = prev;
+            }
+            else
+            {
+                prev = ptr;
+                ptr = ptr->next;
+            }
+    }
+
+    void clear()
+    {
+        Node* ptr = firstInsert_;
+        while (ptr)
+        {
+            Node* next = ptr->next;
+            delete ptr;
+            ptr = next;
+        }
+
+        sz_ = 0;
+        firstInsert_ = lastInsert_ = nullptr;
+    }
+
+    bool empty() const { return sz_ == 0; }
+
+    size_t size() const { return sz_; }
+
+    void swap(FixedList& other)
+    {
+        std::swap(firstInsert_, other.firstInsert_);
+        std::swap(lastInsert_,  other.lastInsert_);
+        std::swap(sz_,          other.sz_);
+    }
+
+private:
+    FixedList           (const FixedList&) = delete;
+    FixedList& operator=(const FixedList&) = delete;
+
+    Node* firstInsert_ = nullptr;
+    Node* lastInsert_  = nullptr; //point to last insertion; required by efficient emplace_back()
+    size_t sz_ = 0;
+};
+
+
+//just as fast as FixedList, but simpler, more CPU-cache-friendly => superseeds FixedList!
+template <class T>
+class FixedVector
+{
+public:
+    FixedVector() {}
+
+    /*
+    class EndIterator {}; //just like FixedList: no iterator invalidation after emplace_back()
+
+    template <class V>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this random-access if needed
+    {
+    public:
+        FixedIterator(std::vector<std::unique_ptr<T>>& cont, size_t pos) : cont_(cont), pos_(pos) {}
+        FixedIterator& operator++() { ++pos_; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, EndIterator) { return lhs.pos_ == lhs.cont_.size(); }
+        inline friend bool operator!=(const FixedIterator& lhs, EndIterator) { return !(lhs == EndIterator()); }
+        V& operator* () const { return  *cont_[pos_]; }
+        V* operator->() const { return &*cont_[pos_]; }
+    private:
+        std::vector<std::unique_ptr<T>>& cont_;
+        size_t pos_ = 0;
+    };
+    */
+
+    template <class IterImpl, class V>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this bidirectional if needed
+    {
+    public:
+        FixedIterator(IterImpl it) : it_(it) {}
+        FixedIterator& operator++() { ++it_; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
+        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
+        V& operator* () const { return  **it_; }
+        V* operator->() const { return &** it_; }
+    private:
+        IterImpl it_;  //TODO: avoid iterator invalidation after emplace_back(); caveat: end() must not store old length!
+    };
+
+    using value_type      = T;
+    using iterator        = FixedIterator<typename std::vector<std::unique_ptr<T>>::iterator,             T>;
+    using const_iterator  = FixedIterator<typename std::vector<std::unique_ptr<T>>::const_iterator, const T>;
+    using reference       =       T&;
+    using const_reference = const T&;
+
+    iterator begin() { return items_.begin(); }
+    iterator end  () { return items_.end  (); }
+
+    const_iterator begin() const { return items_.begin(); }
+    const_iterator end  () const { return items_.end  (); }
+
+    reference       front()       { return *items_.front(); }
+    const_reference front() const { return *items_.front(); }
+
+    reference&       back()       { return *items_.back(); }
+    const_reference& back() const { return *items_.back(); }
+
+    template <class... Args>
+    void emplace_back(Args&& ... args)
+    {
+        items_.push_back(std::make_unique<T>(std::forward<Args>(args)...));
+    }
+
+    template <class Predicate>
+    void remove_if(Predicate pred)
+    {
+        erase_if(items_, [&](const std::unique_ptr<T>& p) { return pred(*p); });
+    }
+
+    void   clear() { items_.clear(); }
+    bool   empty() const { return items_.empty(); }
+    size_t size () const { return items_.size(); }
+    void swap(FixedVector& other) { items_.swap(other.items_); }
+
+private:
+    FixedVector           (const FixedVector&) = delete;
+    FixedVector& operator=(const FixedVector&) = delete;
+
+    std::vector<std::unique_ptr<T>> items_;
+};
+}
+
+#endif //FIXED_LIST_H_01238467085684139453534
-- 
cgit