Added DynamicArray, DynamicList, and HashMap

modules/beast_core/containers/DynamicArray.h

@@ -0,0 +1,728 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_CORE_CONTAINERS_DYNAMICARRAY_H_INCLUDED
+#define BEAST_CORE_CONTAINERS_DYNAMICARRAY_H_INCLUDED
+
+template <typename, typename>
+class DynamicArray;
+
+namespace detail
+{
+
+template <typename V>
+class DynamicArrayIterator
+    : public std::iterator <std::random_access_iterator_tag,
+        typename V::size_type>
+{
+public:
+    typedef typename copyconst <V, typename V::value_type>::type
+
+                              value_type;
+    typedef value_type*       pointer;
+    typedef value_type&       reference;
+    typedef std::ptrdiff_t    difference_type;
+    typedef typename V::size_type size_type;
+
+    DynamicArrayIterator (V* v = nullptr, size_type pos = 0) noexcept
+        : m_v (v)
+        , m_pos (pos)
+    {
+    }
+
+    template <typename W>
+    DynamicArrayIterator (DynamicArrayIterator <W> const& u) noexcept
+        : m_v (u.m_v)
+        , m_pos (u.m_pos)
+    {
+    }
+
+    template <typename W>
+    DynamicArrayIterator& operator= (DynamicArrayIterator <W> const& u) noexcept
+    {
+        m_v = u.m_v;
+        m_pos = u.m_pos;
+        return *this;
+    }
+
+    template <typename W>
+    bool operator== (DynamicArrayIterator <W> const& u) const noexcept
+    {
+        return (m_v == u.m_v) && (m_pos == u.m_pos);
+    }
+
+    template <typename W>
+    bool operator!= (DynamicArrayIterator <W> const& u) const noexcept
+    {
+        return ! ((*this) == u);
+    }
+
+    reference operator* () const noexcept
+    {
+        return dereference ();
+    }
+
+    pointer operator-> () const noexcept
+    {
+        return &dereference ();
+    }
+
+    DynamicArrayIterator& operator++ () noexcept
+    {
+        increment (1);
+        return *this;
+    }
+
+    DynamicArrayIterator operator++ (int) noexcept
+    {
+        DynamicArrayIterator const result (*this);
+        increment (1);
+        return result;
+    }
+
+    DynamicArrayIterator& operator-- () noexcept
+    {
+        decrement (1);
+        return *this;
+    }
+
+    DynamicArrayIterator operator-- (int) noexcept
+    {
+        DynamicArrayIterator const result (*this);
+        decrement (1);
+        return result;
+    }
+
+    DynamicArrayIterator& operator+= (difference_type n) noexcept
+    {
+        increment (n);
+        return *this;
+    }
+
+    DynamicArrayIterator& operator-= (difference_type n) noexcept
+    {
+        decrement (n);
+        return *this;
+    }
+
+    DynamicArrayIterator operator+ (difference_type n) noexcept
+    {
+        return DynamicArrayIterator (m_v, m_pos + n);
+    }
+
+    DynamicArrayIterator operator- (difference_type n) noexcept
+    {
+        return DynamicArrayIterator (m_v, m_pos - n);
+    }
+
+    template <typename W>
+    difference_type operator- (DynamicArrayIterator <W> const& rhs) const noexcept
+    {
+        return m_pos - rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator< (DynamicArrayIterator <W> const& rhs) const noexcept
+    {
+        return m_pos < rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator> (DynamicArrayIterator <W> const& rhs) const noexcept
+    {
+        return m_pos > rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator<= (DynamicArrayIterator <W> const& rhs) const noexcept
+    {
+        return m_pos <= rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator>= (DynamicArrayIterator <W> const& rhs) const noexcept
+    {
+        return m_pos >= rhs.m_pos;
+    }
+
+    reference operator[] (difference_type n) noexcept
+    {
+        return (*m_v)[m_pos + n];
+    }
+
+private:
+    reference dereference () const noexcept
+    {
+        return (*m_v) [m_pos];
+    }
+
+    void increment (difference_type n) noexcept
+    {
+        m_pos += n;
+    }
+
+    void decrement (difference_type n) noexcept
+    {
+        m_pos -= n;
+    }
+
+private:
+    template <typename>
+    friend class DynamicArrayIterator;
+
+    V* m_v;
+    size_type m_pos;
+};
+
+//------------------------------------------------------------------------------
+
+template <typename V>
+DynamicArrayIterator <V> operator+ (
+    typename DynamicArrayIterator <V>::difference_type n,
+        DynamicArrayIterator <V> iter) noexcept
+{
+    return iter + n;
+}
+
+template <typename V>
+DynamicArrayIterator <V> operator- (
+    typename DynamicArrayIterator <V>::difference_type n,
+        DynamicArrayIterator <V> iter) noexcept
+{
+    return iter - n;
+}
+
+//------------------------------------------------------------------------------
+
+template <typename V>
+class DynamicArrayReverseIterator
+    : public std::iterator <std::random_access_iterator_tag,
+        typename V::size_type>
+{
+public:
+    typedef typename copyconst <V, typename V::value_type>::type
+
+                              value_type;
+    typedef value_type*       pointer;
+    typedef value_type&       reference;
+    typedef std::ptrdiff_t    difference_type;
+    typedef typename V::size_type size_type;
+
+    DynamicArrayReverseIterator (V* v = nullptr, difference_type pos = 0) noexcept
+        : m_v (v)
+        , m_pos (pos)
+    {
+    }
+
+    template <typename W>
+    DynamicArrayReverseIterator (DynamicArrayReverseIterator <W> const& u) noexcept
+        : m_v (u.m_v)
+        , m_pos (u.m_pos)
+    {
+    }
+
+    template <typename W>
+    DynamicArrayReverseIterator& operator= (DynamicArrayReverseIterator <W> const& u) noexcept
+    {
+        m_v = u.m_v;
+        m_pos = u.m_pos;
+        return *this;
+    }
+
+    template <typename W>
+    bool operator== (DynamicArrayReverseIterator <W> const& u) const noexcept
+    {
+        return (m_v == u.m_v) && (m_pos == u.m_pos);
+    }
+
+    template <typename W>
+    bool operator!= (DynamicArrayReverseIterator <W> const& u) const noexcept
+    {
+        return ! ((*this) == u);
+    }
+
+    reference operator* () const noexcept
+    {
+        return dereference ();
+    }
+
+    pointer operator-> () const noexcept
+    {
+        return &dereference ();
+    }
+
+    DynamicArrayReverseIterator& operator++ () noexcept
+    {
+        increment (1);
+        return *this;
+    }
+
+    DynamicArrayReverseIterator operator++ (int) noexcept
+    {
+        DynamicArrayReverseIterator const result (*this);
+        increment (1);
+        return result;
+    }
+
+    DynamicArrayReverseIterator& operator-- () noexcept
+    {
+        decrement (1);
+        return *this;
+    }
+
+    DynamicArrayReverseIterator operator-- (int) noexcept
+    {
+        DynamicArrayReverseIterator const result (*this);
+        decrement (1);
+        return result;
+    }
+
+    DynamicArrayReverseIterator& operator+= (difference_type n) noexcept
+    {
+        increment (n);
+        return *this;
+    }
+
+    DynamicArrayReverseIterator& operator-= (difference_type n) noexcept
+    {
+        decrement (n);
+        return *this;
+    }
+
+    DynamicArrayReverseIterator operator+ (difference_type n) noexcept
+    {
+        return DynamicArrayReverseIterator (m_v, m_pos - n);
+    }
+
+    DynamicArrayReverseIterator operator- (difference_type n) noexcept
+    {
+        return DynamicArrayReverseIterator (m_v, m_pos + n);
+    }
+
+    template <typename W>
+    difference_type operator- (DynamicArrayReverseIterator <W> const& rhs) const noexcept
+    {
+        return rhs.m_pos - m_pos;
+    }
+
+    template <typename W>
+    bool operator< (DynamicArrayReverseIterator <W> const& rhs) const noexcept
+    {
+        return m_pos > rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator> (DynamicArrayReverseIterator <W> const& rhs) const noexcept
+    {
+        return m_pos < rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator<= (DynamicArrayReverseIterator <W> const& rhs) const noexcept
+    {
+        return m_pos >= rhs.m_pos;
+    }
+
+    template <typename W>
+    bool operator>= (DynamicArrayReverseIterator <W> const& rhs) const noexcept
+    {
+        return m_pos <= rhs.m_pos;
+    }
+
+    reference operator[] (difference_type n) noexcept
+    {
+        return (*m_v)[(m_pos - 1) - n];
+    }
+
+private:
+    template <typename>
+    friend class DynamicArrayReverseIterator;
+
+    reference dereference () const noexcept
+    {
+        return (*m_v) [m_pos - 1];
+    }
+
+    void increment (difference_type n) noexcept
+    {
+        m_pos -= n;
+    }
+
+    void decrement (difference_type n) noexcept
+    {
+        m_pos += n;
+    }
+
+    V* m_v;
+    difference_type m_pos;
+};
+
+//------------------------------------------------------------------------------
+
+template <typename V>
+DynamicArrayReverseIterator <V> operator+ (
+    typename DynamicArrayReverseIterator <V>::difference_type n,
+        DynamicArrayReverseIterator <V> iter) noexcept
+{
+    return iter + n;
+}
+
+template <typename V>
+DynamicArrayReverseIterator <V> operator- (
+    typename DynamicArrayReverseIterator <V>::difference_type n,
+        DynamicArrayReverseIterator <V> iter) noexcept
+{
+    return iter - n;
+}
+
+}
+
+//------------------------------------------------------------------------------
+
+template <typename T,
+          typename Allocator = std::allocator <char> >
+class DynamicArray
+{
+private:
+    typedef PARAMETER_TYPE (T) TParam;
+
+    typedef std::vector <T*> handles_t;
+
+public:
+    enum
+    {
+        defaultBlocksize = 1000,
+        growthPercentage = 10
+    };
+
+    typedef T                 value_type;
+    typedef Allocator         allocator_type;
+    typedef std::size_t       size_type;
+    typedef std::ptrdiff_t    difference_type;
+    typedef value_type*       pointer;
+    typedef value_type&       reference;
+    typedef value_type const* const_pointer;
+    typedef value_type const& const_reference;
+
+    typedef detail::DynamicArrayIterator <DynamicArray <T> > iterator;
+
+    typedef detail::DynamicArrayIterator <DynamicArray <T> const> const_iterator;
+
+    typedef detail::DynamicArrayReverseIterator <DynamicArray <T> > reverse_iterator;
+
+    typedef detail::DynamicArrayReverseIterator <DynamicArray <T> const> const_reverse_iterator;
+
+    //--------------------------------------------------------------------------
+
+    explicit DynamicArray (size_type blocksize = defaultBlocksize) noexcept
+        : m_blocksize (blocksize)
+        , m_capacity (0)
+        , m_size (0)
+    {
+    }
+
+    ~DynamicArray()
+    {
+        clear ();
+        shrink_to_fit ();
+    }
+
+    /** Replace the array with 'count' copies of a default-constructed T.
+    */
+    void assign (size_type count)
+    {
+        clear ();
+        resize (count);
+    }
+
+    //--------------------------------------------------------------------------
+
+    reference at (size_type pos)
+    {
+        if (pos >= size ())
+            Throw (std::out_of_range ("bad pos"), __FILE__, __LINE__);
+        return get (pos);
+    }
+
+    const_reference at (size_type pos) const
+    {
+        if (pos >= size ())
+            Throw (std::out_of_range ("bad pos"), __FILE__, __LINE__);
+        return get (pos);
+    }
+
+    reference operator[] (size_type pos) noexcept
+    {
+        return get (pos);
+    }
+
+    const_reference operator[] (size_type pos) const noexcept
+    {
+        return get (pos);
+    }
+
+    reference front () noexcept
+    {
+        return get (0);
+    }
+
+    const_reference front () const noexcept
+    {
+        return get (0);
+    }
+
+    reference back () noexcept
+    {
+        return get (size () - 1);
+    }
+
+    const_reference back () const noexcept
+    {
+        return get (size () - 1);
+    }
+
+    //--------------------------------------------------------------------------
+
+    iterator begin () noexcept
+    {
+        return iterator (this, 0);
+    }
+
+    const_iterator begin () const noexcept
+    {
+        return const_iterator (this, 0);
+    }
+
+    const_iterator cbegin () const noexcept
+    {
+        return const_iterator (this, 0);
+    }
+
+    iterator end () noexcept
+    {
+        return iterator (this, size ());
+    }
+
+    const_iterator end () const noexcept
+    {
+        return const_iterator (this, size ());
+    }
+
+    const_iterator cend () const noexcept
+    {
+        return const_iterator (this, size ());
+    }
+
+    reverse_iterator rbegin () noexcept
+    {
+        return reverse_iterator (this, size ());
+    }
+
+    const_reverse_iterator rbegin () const noexcept
+    {
+        return const_reverse_iterator (this, size ());
+    }
+
+    const_reverse_iterator crbegin () const noexcept
+    {
+        return const_reverse_iterator (this, size ());
+    }
+
+    reverse_iterator rend () noexcept
+    {
+        return reverse_iterator (this, 0);
+    }
+
+    const_reverse_iterator rend () const noexcept
+    {
+        return const_reverse_iterator (this, 0);
+    }
+
+    const_reverse_iterator crend () const noexcept
+    {
+        return const_reverse_iterator (this, 0);
+    }
+
+    //--------------------------------------------------------------------------
+
+    bool empty () const noexcept
+    {
+        return m_size == 0;
+    }
+
+    size_type size () const noexcept
+    {
+        return m_size;
+    }
+
+    size_type max_size () const noexcept
+    {
+        return std::numeric_limits <size_type>::max ();
+    }
+
+    void reserve (size_type new_cap)
+    {
+        new_cap = m_blocksize * (
+            (new_cap + m_blocksize - 1) / m_blocksize);
+        if (new_cap > max_size ())
+            Throw (std::length_error ("new_cap > max_size"), __FILE__, __LINE__);
+        if (new_cap <= m_capacity)
+            return;
+        size_type const n (new_cap / m_blocksize);
+        m_handles.reserve (n);
+        for (size_type i = m_handles.size (); i < n; ++i)
+            m_handles.push_back (static_cast <T*> (std::malloc (
+                m_blocksize * sizeof (T))));
+        m_capacity = new_cap;
+    }
+
+    size_type capacity () const noexcept
+    {
+        return m_capacity;
+    }
+
+    void shrink_to_fit ()
+    {
+        size_type const handles (
+            (size () + m_blocksize - 1) / m_blocksize);
+        m_capacity = handles * m_blocksize;
+        for (size_type i = m_handles.size (); i-- > handles;)
+        {
+            std::free (m_handles [i]);
+            m_handles.erase (m_handles.begin () + i);
+        }
+    }
+
+    //--------------------------------------------------------------------------
+
+    void clear ()
+    {
+        resize (0);
+    }
+
+    iterator push_back (TParam value)
+    {
+        ::new (alloc ()) T (value);
+        return iterator (this, size () - 1);
+    }
+
+    iterator emplace_back ()
+    {
+        ::new (alloc ()) T ();
+        return iterator (this, size () - 1);
+    }
+
+    template <class A1>
+    iterator emplace_back (A1 a1)
+    {
+        ::new (alloc ()) T (a1);
+        return iterator (this, size () - 1);
+    }
+
+    template <class A1, class A2>
+    iterator emplace_back (A1 a1, A2 a2)
+    {
+        ::new (alloc ()) T (a1, a2);
+        return iterator (this, size () - 1);
+    }
+    
+    template <class A1, class A2, class A3>
+    iterator emplace_back (A1 a1, A2 a2, A3 a3)
+    {
+        ::new (alloc ()) T (a1, a2, a3);
+        return iterator (this, size () - 1);
+    }
+    
+    template <class A1, class A2, class A3, class A4>
+    iterator emplace_back (A1 a1, A2 a2, A3 a3, A4 a4)
+    {
+        ::new (alloc ()) T (a1, a2, a3, a4);
+        return iterator (this, size () - 1);
+    }
+
+    template <class A1, class A2, class A3, class A4, class A5>
+    iterator emplace_back (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    {
+        ::new (alloc ()) T (a1, a2, a3, a4, a5);
+        return iterator (this, size () - 1);
+    }
+   
+    void pop_back ()
+    {
+        resize (size () - 1);
+    }
+
+    void resize (size_type count)
+    {
+        while (count > size ())
+            ::new (alloc ()) T;
+
+        while (count < size ())
+            get (--m_size).~T ();
+    }
+
+    void resize (size_type count, TParam value)
+    {
+        while (count > size ())
+            ::new (alloc ()) T (value);
+
+        while (count < size ())
+            get (--m_size).~T ();
+    }
+
+    void swap (DynamicArray& other)
+    {
+        std::swap (m_blocksize, other.m_blocksize);
+        std::swap (m_size,      other.m_size);
+        std::swap (m_capacity,  other.m_capacity);
+        std::swap (m_handles,   other.m_handles);
+    }
+
+private:
+    reference get (size_type pos) noexcept
+    {
+        size_type const index (pos / m_blocksize);
+        size_type const offset (pos % m_blocksize);
+        return m_handles [index] [offset];
+    }
+
+    const_reference get (size_type pos) const noexcept
+    {
+        size_type const index (pos / m_blocksize);
+        size_type const offset (pos % m_blocksize);
+        return m_handles [index] [offset];
+    }
+
+    T* alloc () noexcept
+    {
+        size_type const needed (size () + 1);
+        if (capacity () < needed)
+            reserve ((needed * (100 + growthPercentage) + 99) / 100);
+        return &get (m_size++);
+    }
+
+private:
+    Allocator m_allocator;
+    size_type m_blocksize;
+    size_type m_capacity;
+    size_type m_size;
+    handles_t m_handles;
+};
+
+#endif