@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,304 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,399 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/