@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/container/simple_vector.hpp

@@ -0,0 +1,304 @@
+/*******************************************************************************
+ * tlx/container/simple_vector.hpp
+ *
+ * Copied and modified from STXXL, see http://stxxl.org
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2002 Roman Dementiev <dementiev@mpi-sb.mpg.de>
+ * Copyright (C) 2008, 2011 Andreas Beckmann <beckmann@cs.uni-frankfurt.de>
+ * Copyright (C) 2013-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_CONTAINER_SIMPLE_VECTOR_HEADER
+#define TLX_CONTAINER_SIMPLE_VECTOR_HEADER
+
+#include <algorithm>
+#include <cstdlib>
+#include <new>
+#include <utility>
+
+namespace tlx {
+
+//! \addtogroup tlx_container
+//! \{
+
+//! enum class to select SimpleVector object initialization
+enum class SimpleVectorMode
+{
+    //! Initialize objects at allocation and destroy on deallocation
+    Normal,
+    //! Do not initialize objects at allocation, but destroy on
+    //! deallocation. Thus, all objects must be constructed from outside.
+    NoInitButDestroy,
+    //! Do not initialize objects at allocation and do not destroy them.
+    NoInitNoDestroy,
+};
+
+/*!
+ * Simpler non-growing vector without initialization.
+ *
+ * SimpleVector can be used a replacement for std::vector when only a
+ * non-growing array of simple types is needed. The advantages of SimpleVector
+ * are that it does not initilize memory for POD types (-> faster), while normal
+ * structs are supported as well if default-contractible. The simple pointer
+ * types allow faster compilation and is less error prone to copying and other
+ * problems.
+ */
+template <typename ValueType, SimpleVectorMode Mode = SimpleVectorMode::Normal>
+class SimpleVector
+{
+public:
+    using value_type = ValueType;
+    using size_type = size_t;
+
+private:
+    //! size of allocated memory
+    size_type size_;
+
+    //! pointer to allocated memory area
+    value_type* array_;
+
+public:
+    // *** simple pointer iterators
+
+    using iterator = value_type*;
+    using const_iterator = const value_type*;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+
+public:
+    //! allocate empty simple vector
+    SimpleVector() : size_(0), array_(nullptr)
+    {
+    }
+
+    //! allocate vector's memory
+    explicit SimpleVector(const size_type& sz) : size_(sz), array_(nullptr)
+    {
+        if (size_ > 0)
+            array_ = create_array(size_);
+    }
+
+    //! non-copyable: delete copy-constructor
+    SimpleVector(const SimpleVector&) = delete;
+    //! non-copyable: delete assignment operator
+    SimpleVector& operator=(const SimpleVector&) = delete;
+
+    //! move-constructor
+    SimpleVector(SimpleVector&& v) noexcept : size_(v.size_), array_(v.array_)
+    {
+        v.size_ = 0, v.array_ = nullptr;
+    }
+
+    //! move-assignment
+    SimpleVector& operator=(SimpleVector&& v) noexcept
+    {
+        if (&v == this)
+            return *this;
+        destroy_array(array_, size_);
+        size_ = v.size_, array_ = v.array_;
+        v.size_ = 0, v.array_ = nullptr;
+        return *this;
+    }
+
+    //! swap vector with another one
+    void swap(SimpleVector& obj) noexcept
+    {
+        std::swap(size_, obj.size_);
+        std::swap(array_, obj.array_);
+    }
+
+    //! delete vector
+    ~SimpleVector()
+    {
+        destroy_array(array_, size_);
+    }
+
+    //! return iterator to beginning of vector
+    iterator data() noexcept
+    {
+        return array_;
+    }
+
+    //! return iterator to beginning of vector
+    const_iterator data() const noexcept
+    {
+        return array_;
+    }
+
+    //! return number of items in vector
+    size_type size() const noexcept
+    {
+        return size_;
+    }
+
+    //! return mutable iterator to first element
+    iterator begin() noexcept
+    {
+        return array_;
+    }
+
+    //! return constant iterator to first element
+    const_iterator begin() const noexcept
+    {
+        return array_;
+    }
+
+    //! return constant iterator to first element
+    const_iterator cbegin() const noexcept
+    {
+        return begin();
+    }
+
+    //! return mutable iterator beyond last element
+    iterator end() noexcept
+    {
+        return array_ + size_;
+    }
+
+    //! return constant iterator beyond last element
+    const_iterator end() const noexcept
+    {
+        return array_ + size_;
+    }
+
+    //! return constant iterator beyond last element
+    const_iterator cend() const noexcept
+    {
+        return end();
+    }
+
+    //! returns reference to the last element in the container
+    reference front() noexcept
+    {
+        return array_[0];
+    }
+
+    //! returns reference to the first element in the container
+    const_reference front() const noexcept
+    {
+        return array_[0];
+    }
+
+    //! returns reference to the first element in the container
+    reference back() noexcept
+    {
+        return array_[size_ - 1];
+    }
+
+    //! returns reference to the last element in the container
+    const_reference back() const noexcept
+    {
+        return array_[size_ - 1];
+    }
+
+    //! return the i-th position of the vector
+    reference operator[](size_type i) noexcept
+    {
+        return *(begin() + i);
+    }
+
+    //! return constant reference to the i-th position of the vector
+    const_reference operator[](size_type i) const noexcept
+    {
+        return *(begin() + i);
+    }
+
+    //! return the i-th position of the vector
+    reference at(size_type i) noexcept
+    {
+        return *(begin() + i);
+    }
+
+    //! return constant reference to the i-th position of the vector
+    const_reference at(size_type i) const noexcept
+    {
+        return *(begin() + i);
+    }
+
+    //! resize the array to contain exactly new_size items
+    void resize(size_type new_size)
+    {
+        if (array_)
+        {
+            value_type* tmp = array_;
+            array_ = create_array(new_size);
+            std::move(tmp, tmp + std::min(size_, new_size), array_);
+            destroy_array(tmp, size_);
+            size_ = new_size;
+        }
+        else
+        {
+            array_ = create_array(new_size);
+            size_ = new_size;
+        }
+    }
+
+    //! deallocate contained array
+    void destroy()
+    {
+        destroy_array(array_, size_);
+        array_ = nullptr;
+        size_ = 0;
+    }
+
+    //! Zero the whole array content.
+    void fill(const value_type& v = value_type()) noexcept
+    {
+        std::fill(array_, array_ + size_, v);
+    }
+
+private:
+    static ValueType* create_array(size_t size)
+    {
+        switch (Mode)
+        {
+        case SimpleVectorMode::Normal:
+            // with normal object construction
+            return new value_type[size];
+        case SimpleVectorMode::NoInitButDestroy:
+        case SimpleVectorMode::NoInitNoDestroy:
+            // operator new allocates bytes
+            return static_cast<ValueType*>(operator new(size *
+                                                        sizeof(ValueType)));
+        }
+        std::abort();
+    }
+
+    static void destroy_array(ValueType* array, size_t size)
+    {
+        switch (Mode)
+        {
+        case SimpleVectorMode::Normal:
+            // with normal object destruction
+            delete[] array;
+            return;
+        case SimpleVectorMode::NoInitButDestroy:
+            // destroy objects and deallocate memory
+            for (size_t i = 0; i < size; ++i)
+                array[i].~ValueType();
+            operator delete(array);
+            return;
+        case SimpleVectorMode::NoInitNoDestroy:
+            // only deallocate memory
+            operator delete(array);
+            return;
+        }
+        std::abort();
+    }
+};
+
+//! make template alias due to similarity with std::vector
+template <typename T>
+using simple_vector = SimpleVector<T>;
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_CONTAINER_SIMPLE_VECTOR_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/container/splay_tree.hpp

@@ -0,0 +1,399 @@
+/*******************************************************************************
+ * tlx/container/splay_tree.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_CONTAINER_SPLAY_TREE_HEADER
+#define TLX_CONTAINER_SPLAY_TREE_HEADER
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+
+namespace tlx {
+
+//! \addtogroup tlx_container
+//! \{
+
+/******************************************************************************/
+// splay -- free Splay Tree methods
+
+/*
+                An implementation of top-down splaying
+                    D. Sleator <sleator@cs.cmu.edu>
+                             March 1992
+
+  "Splay trees", or "self-adjusting search trees" are a simple and efficient
+  data structure for storing an ordered set.  The data structure consists of a
+  binary tree, without parent pointers, and no additional fields.  It allows
+  searching, insertion, deletion, deletemin, deletemax, splitting, joining, and
+  many other operations, all with amortized logarithmic performance.  Since the
+  trees adapt to the sequence of requests, their performance on real access
+  patterns is typically even better.  Splay trees are described in a number of
+  texts and papers [1,2,3,4,5].
+
+  The code here is adapted from simple top-down splay, at the bottom of page 669
+  of [3].  It can be obtained via anonymous ftp from spade.pc.cs.cmu.edu in
+  directory /usr/sleator/public.
+
+  The chief modification here is that the splay operation works even if the item
+  being splayed is not in the tree, and even if the tree root of the tree is
+  nullptr.  So the line:
+
+                              t = splay(i, t);
+
+  causes it to search for item with key i in the tree rooted at t.  If it's
+  there, it is splayed to the root.  If it isn't there, then the node put at the
+  root is the last one before nullptr that would have been reached in a normal
+  binary search for i.  (It's a neighbor of i in the tree.)  This allows many
+  other operations to be easily implemented, as shown below.
+
+  [1] "Fundamentals of data structures in C", Horowitz, Sahni,
+       and Anderson-Freed, Computer Science Press, pp 542-547.
+  [2] "Data Structures and Their Algorithms", Lewis and Denenberg,
+       Harper Collins, 1991, pp 243-251.
+  [3] "Self-adjusting Binary Search Trees" Sleator and Tarjan,
+       JACM Volume 32, No 3, July 1985, pp 652-686.
+  [4] "Data Structure and Algorithm Analysis", Mark Weiss,
+       Benjamin Cummins, 1992, pp 119-130.
+  [5] "Data Structures, Algorithms, and Performance", Derick Wood,
+       Addison-Wesley, 1993, pp 367-375.
+*/
+
+//! check the tree order, recursively calculate min and max elements
+template <typename Tree, typename Compare>
+bool splay_check(const Tree* t, const Tree*& out_tmin, const Tree*& out_tmax,
+                 const Compare& cmp)
+{
+    if (t == nullptr)
+        return true;
+
+    const Tree *tmin = nullptr, *tmax = nullptr;
+    if (!splay_check(t->left, out_tmin, tmax, cmp) ||
+        !splay_check(t->right, tmin, out_tmax, cmp))
+        return false;
+
+    if (tmax && !cmp(tmax->key, t->key))
+        return false;
+    if (tmin && !cmp(t->key, tmin->key))
+        return false;
+    return true;
+}
+
+//! check the tree order
+template <typename Tree, typename Compare>
+bool splay_check(const Tree* t, const Compare& cmp)
+{
+    if (t == nullptr)
+        return true;
+    const Tree *tmin = nullptr, *tmax = nullptr;
+    return splay_check(t, tmin, tmax, cmp);
+}
+
+//! Splay using the key i (which may or may not be in the tree.)  The starting
+//! root is t, and the tree used is defined by rat size fields are maintained.
+template <typename Key, typename Tree, typename Compare>
+Tree* splay(const Key& k, Tree* t, const Compare& cmp)
+{
+    Tree *N_left = nullptr, *N_right = nullptr;
+    Tree *l = nullptr, *r = nullptr;
+
+    if (t == nullptr)
+        return t;
+
+    for (;;)
+    {
+        if (cmp(k, t->key))
+        {
+            if (t->left == nullptr)
+                break;
+
+            if (cmp(k, t->left->key))
+            {
+                // rotate right
+                Tree* y = t->left;
+                t->left = y->right;
+                y->right = t;
+                t = y;
+                if (t->left == nullptr)
+                    break;
+            }
+            // link right
+            (r ? r->left : N_left) = t;
+            r = t;
+            t = t->left;
+        }
+        else if (cmp(t->key, k))
+        {
+            if (t->right == nullptr)
+                break;
+
+            if (cmp(t->right->key, k))
+            {
+                // rotate left
+                Tree* y = t->right;
+                t->right = y->left;
+                y->left = t;
+                t = y;
+                if (t->right == nullptr)
+                    break;
+            }
+            // link left
+            (l ? l->right : N_right) = t;
+            l = t;
+            t = t->right;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    (l ? l->right : N_right) = (r ? r->left : N_left) = nullptr;
+
+    // assemble
+    (l ? l->right : N_right) = t->left;
+    (r ? r->left : N_left) = t->right;
+    t->left = N_right;
+    t->right = N_left;
+
+    return t;
+}
+
+//! Insert key i into the tree t, if it is not already there.  Before calling
+//! this method, one *MUST* call splay() to rotate the tree to the right
+//! position. Return a pointer to the resulting tree.
+template <typename Tree, typename Compare>
+Tree* splay_insert(Tree* nn, Tree* t, const Compare& cmp)
+{
+    if (t == nullptr)
+    {
+        nn->left = nn->right = nullptr;
+    }
+    else if (cmp(nn->key, t->key))
+    {
+        nn->left = t->left;
+        nn->right = t;
+        t->left = nullptr;
+    }
+    else
+    {
+        nn->right = t->right;
+        nn->left = t;
+        t->right = nullptr;
+    }
+    return nn;
+}
+
+//! Erases i from the tree if it's there.  Return a pointer to the resulting
+//! tree.
+template <typename Key, typename Tree, typename Compare>
+Tree* splay_erase(const Key& k, Tree*& t, const Compare& cmp)
+{
+    if (t == nullptr)
+        return nullptr;
+    t = splay(k, t, cmp);
+    // k == t->key ?
+    if (!cmp(k, t->key) && !cmp(t->key, k))
+    {
+        // found it
+        Tree* r = t;
+        if (t->left == nullptr)
+        {
+            t = t->right;
+        }
+        else
+        {
+            Tree* x = splay(k, t->left, cmp);
+            x->right = t->right;
+            t = x;
+        }
+        return r;
+    }
+
+    // it wasn't there
+    return nullptr;
+}
+
+//! traverse the tree in preorder (left, node, right)
+template <typename Tree, typename Functor>
+void splay_traverse_preorder(const Functor& f, const Tree* t)
+{
+    if (t == nullptr)
+        return;
+    splay_traverse_preorder(f, t->left);
+    f(t);
+    splay_traverse_preorder(f, t->right);
+}
+
+//! traverse the tree in postorder (left, right, node)
+template <typename Tree, typename Functor>
+void splay_traverse_postorder(const Functor& f, Tree* t)
+{
+    if (t == nullptr)
+        return;
+    splay_traverse_postorder(f, t->left);
+    splay_traverse_postorder(f, t->right);
+    f(t);
+}
+
+/******************************************************************************/
+// Splay Tree
+
+template <typename Key, typename Compare = std::less<Key>,
+          bool Duplicates = false, typename Allocator = std::allocator<Key> >
+class SplayTree
+{
+public:
+    //! splay tree node, also seen as public iterator
+    struct Node
+    {
+        Node *left = nullptr, *right = nullptr;
+        Key key;
+
+        explicit Node(const Key& k) : key(k)
+        {
+        }
+    };
+
+    explicit SplayTree(Allocator alloc = Allocator()) : node_allocator_(alloc)
+    {
+    }
+
+    explicit SplayTree(Compare cmp, Allocator alloc = Allocator())
+        : cmp_(cmp), node_allocator_(alloc)
+    {
+    }
+
+    ~SplayTree()
+    {
+        clear();
+    }
+
+    //! insert key into tree if it does not exist, returns true if inserted.
+    bool insert(const Key& k)
+    {
+        if (root_ != nullptr)
+        {
+            root_ = splay(k, root_, cmp_);
+            // k == t->key ?
+            if (!Duplicates && !cmp_(k, root_->key) && !cmp_(root_->key, k))
+            {
+                // it's already there
+                return false;
+            }
+        }
+        Node* nn = new (node_allocator_.allocate(1)) Node(k);
+        root_ = splay_insert(nn, root_, cmp_);
+        size_++;
+        return true;
+    }
+
+    //! erase key from tree, return true if it existed.
+    bool erase(const Key& k)
+    {
+        Node* out = splay_erase(k, root_, cmp_);
+        if (!out)
+            return false;
+        delete_node(out);
+        return true;
+    }
+
+    //! erase node from tree, return true if it existed.
+    bool erase(const Node* n)
+    {
+        return erase(n->key);
+    }
+
+    //! free all nodes
+    void clear()
+    {
+        splay_traverse_postorder([this](Node* n) { delete_node(n); }, root_);
+    }
+
+    //! check if key exists
+    bool exists(const Key& k)
+    {
+        root_ = splay(k, root_, cmp_);
+        return !cmp_(root_->key, k) && !cmp_(k, root_->key);
+    }
+
+    //! return number of items in tree
+    size_t size() const
+    {
+        return size_;
+    }
+
+    //! return true if tree is empty
+    bool empty() const
+    {
+        return size_ == 0;
+    }
+
+    //! find tree node containing key or return smallest key larger than k
+    Node* find(const Key& k)
+    {
+        return (root_ = splay(k, root_, cmp_));
+    }
+
+    //! check the tree order
+    bool check() const
+    {
+        return splay_check(root_, cmp_);
+    }
+
+    //! traverse the whole tree in preorder (key order)s
+    template <typename Functor>
+    void traverse_preorder(const Functor& f) const
+    {
+        splay_traverse_preorder([&f](const Node* n) { f(n->key); }, root_);
+    }
+
+private:
+    //! root tree node
+    Node* root_ = nullptr;
+    //! number of items in tree container
+    size_t size_ = 0;
+    //! key comparator
+    Compare cmp_;
+    //! key allocator
+    Allocator alloc_;
+
+    //! node allocator
+    typedef
+        typename std::allocator_traits<Allocator>::template rebind_alloc<Node>
+            node_alloc_type;
+
+    //! node allocator
+    node_alloc_type node_allocator_;
+
+    //! delete node
+    void delete_node(Node* n)
+    {
+        n->~Node();
+        node_allocator_.deallocate(n, 1);
+        size_--;
+    }
+};
+
+template <typename Key, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<Key> >
+using splay_set = SplayTree<Key, Compare, /* Duplicates */ false, Allocator>;
+
+template <typename Key, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<Key> >
+using splay_multiset =
+    SplayTree<Key, Compare, /* Duplicates */ true, Allocator>;
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_CONTAINER_SPLAY_TREE_HEADER
+
+/******************************************************************************/