dlib C++ Library - array_kernel.h

    // Copyright (C) 2003  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_ARRAY_KERNEl_2_
    #define DLIB_ARRAY_KERNEl_2_

    #include "array_kernel_abstract.h"
    #include "../interfaces/enumerable.h"
    #include "../algs.h"
    #include "../serialize.h"
    #include "../sort.h"
    #include "../is_kind.h"

    namespace dlib
    {

        template <
            typename T,
            typename mem_manager = default_memory_manager
            >
        class array : public enumerable<T>
        {

            /*!
                INITIAL VALUE
                    - array_size == 0
                    - max_array_size == 0
                    - array_elements == 0
                    - pos == 0
                    - last_pos == 0
                    - _at_start == true

                CONVENTION
                    - array_size == size()
                    - max_array_size == max_size()
                    - if (max_array_size > 0)
                        - array_elements == pointer to max_array_size elements of type T
                    - else
                        - array_elements == 0

                    - if (array_size > 0)
                        - last_pos == array_elements + array_size - 1
                    - else
                        - last_pos == 0

                    - at_start() == _at_start
                    - current_element_valid() == pos != 0
                    - if (current_element_valid()) then
                        - *pos == element()
            !*/

        public:

            // These typedefs are here for backwards compatibility with old versions of dlib.
            typedef array kernel_1a;
            typedef array kernel_1a_c;
            typedef array kernel_2a;
            typedef array kernel_2a_c;
            typedef array sort_1a;
            typedef array sort_1a_c;
            typedef array sort_1b;
            typedef array sort_1b_c;
            typedef array sort_2a;
            typedef array sort_2a_c;
            typedef array sort_2b;
            typedef array sort_2b_c;
            typedef array expand_1a;
            typedef array expand_1a_c;
            typedef array expand_1b;
            typedef array expand_1b_c;
            typedef array expand_1c;
            typedef array expand_1c_c;
            typedef array expand_1d;
            typedef array expand_1d_c;

            typedef T type;
            typedef T value_type;
            typedef mem_manager mem_manager_type;

            array (
            ) :
                array_size(0),
                max_array_size(0),
                array_elements(0),
                pos(0),
                last_pos(0),
                _at_start(true)
            {}

            array(const array&) = delete;
            array& operator=(array&) = delete;

            array(
                array&& item
            ) : array()
            {
                swap(item);
            }

            array& operator=(
                array&& item
            )
            {
                swap(item);
                return *this;
            }

            explicit array (
                size_t new_size
            ) :
                array_size(0),
                max_array_size(0),
                array_elements(0),
                pos(0),
                last_pos(0),
                _at_start(true)
            {
                resize(new_size);
            }

            ~array (
            );

            void clear (
            );

            inline const T& operator[] (
                size_t pos
            ) const;

            inline T& operator[] (
                size_t pos
            );

            void set_size (
                size_t size
            );

            inline size_t max_size(
            ) const;

            void set_max_size(
                size_t max
            );

            void swap (
                array& item
            );

            // functions from the enumerable interface
            inline size_t size (
            ) const;

            inline bool at_start (
            ) const;

            inline void reset (
            ) const;

            bool current_element_valid (
            ) const;

            inline const T& element (
            ) const;

            inline T& element (
            );

            bool move_next (
            ) const;

            void sort (
            );

            void resize (
                size_t new_size
            );

            const T& back (
            ) const;

            T& back (
            );

            void pop_back (
            );

            void pop_back (
                T& item
            );

            void push_back (
                T& item
            );

            void push_back (
                T&& item
            );

            typedef T* iterator;
            typedef const T* const_iterator;
            iterator                begin()                         { return array_elements; }
            const_iterator          begin() const                   { return array_elements; }
            iterator                end()                           { return array_elements+array_size; }
            const_iterator          end() const                     { return array_elements+array_size; }

        private:

            typename mem_manager::template rebind<T>::other pool;

            // data members
            size_t array_size;
            size_t max_array_size;
            T* array_elements;

            mutable T* pos;
            T* last_pos;
            mutable bool _at_start;

        };

        template <
            typename T,
            typename mem_manager
            >
        inline void swap (
            array<T,mem_manager>& a,
            array<T,mem_manager>& b
        ) { a.swap(b); }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void serialize (
            const array<T,mem_manager>& item,
            std::ostream& out
        )
        {
            try
            {
                serialize(item.max_size(),out);
                serialize(item.size(),out);

                for (size_t i = 0; i < item.size(); ++i)
                    serialize(item[i],out);
            }
            catch (serialization_error& e)
            {
                throw serialization_error(e.info + "\n   while serializing object of type array");
            }
        }

        template <
            typename T,
            typename mem_manager
            >
        void deserialize (
            array<T,mem_manager>& item,
            std::istream& in
        )
        {
            try
            {
                size_t max_size, size;
                deserialize(max_size,in);
                deserialize(size,in);
                item.set_max_size(max_size);
                item.set_size(size);
                for (size_t i = 0; i < size; ++i)
                    deserialize(item[i],in);
            }
            catch (serialization_error& e)
            {
                item.clear();
                throw serialization_error(e.info + "\n   while deserializing object of type array");
            }
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
    // member function definitions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        array<T,mem_manager>::
        ~array (
        )
        {
            if (array_elements)
            {
                pool.deallocate_array(array_elements);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        clear (
        )
        {
            reset();
            last_pos = 0;
            array_size = 0;
            if (array_elements)
            {
                pool.deallocate_array(array_elements);
            }
            array_elements = 0;
            max_array_size = 0;

        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        const T& array<T,mem_manager>::
        operator[] (
            size_t pos
        ) const
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( pos < this->size() ,
                "\tconst T& array::operator[]"
                << "\n\tpos must < size()"
                << "\n\tpos: " << pos
                << "\n\tsize(): " << this->size()
                << "\n\tthis: " << this
                );

            return array_elements[pos];
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        T& array<T,mem_manager>::
        operator[] (
            size_t pos
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( pos < this->size() ,
                "\tT& array::operator[]"
                << "\n\tpos must be < size()"
                << "\n\tpos: " << pos
                << "\n\tsize(): " << this->size()
                << "\n\tthis: " << this
                );

            return array_elements[pos];
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        set_size (
            size_t size
        )
        {
            // make sure requires clause is not broken
            DLIB_CASSERT(( size <= this->max_size() ),
                "\tvoid array::set_size"
                << "\n\tsize must be <= max_size()"
                << "\n\tsize: " << size
                << "\n\tmax size: " << this->max_size()
                << "\n\tthis: " << this
                );

            reset();
            array_size = size;
            if (size > 0)
                last_pos = array_elements + size - 1;
            else
                last_pos = 0;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        size_t array<T,mem_manager>::
        size (
        ) const
        {
            return array_size;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        set_max_size(
            size_t max
        )
        {
            reset();
            array_size = 0;
            last_pos = 0;
            if (max != 0)
            {
                // if new max size is different
                if (max != max_array_size)
                {
                    if (array_elements)
                    {
                        pool.deallocate_array(array_elements);
                    }
                    // try to get more memroy
                    try { array_elements = pool.allocate_array(max); }
                    catch (...) { array_elements = 0;  max_array_size = 0; throw; }
                    max_array_size = max;
                }

            }
            // if the array is being made to be zero
            else
            {
                if (array_elements)
                    pool.deallocate_array(array_elements);
                max_array_size = 0;
                array_elements = 0;
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        size_t array<T,mem_manager>::
        max_size (
        ) const
        {
            return max_array_size;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        swap (
            array<T,mem_manager>& item
        )
        {
            auto             array_size_temp        = item.array_size;
            auto             max_array_size_temp    = item.max_array_size;
            T*               array_elements_temp    = item.array_elements;

            item.array_size         = array_size;
            item.max_array_size     = max_array_size;
            item.array_elements     = array_elements;

            array_size        = array_size_temp;
            max_array_size    = max_array_size_temp;
            array_elements    = array_elements_temp;

            exchange(_at_start,item._at_start);
            exchange(pos,item.pos);
            exchange(last_pos,item.last_pos);
            pool.swap(item.pool);
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
    //           enumerable function definitions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        bool array<T,mem_manager>::
        at_start (
        ) const
        {
            return _at_start;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        reset (
        ) const
        {
            _at_start = true;
            pos = 0;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        bool array<T,mem_manager>::
        current_element_valid (
        ) const
        {
            return pos != 0;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        const T& array<T,mem_manager>::
        element (
        ) const
        {
            // make sure requires clause is not broken
            DLIB_ASSERT(this->current_element_valid(),
                "\tconst T& array::element()"
                << "\n\tThe current element must be valid if you are to access it."
                << "\n\tthis: " << this
                );

            return *pos;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        T& array<T,mem_manager>::
        element (
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT(this->current_element_valid(),
                "\tT& array::element()"
                << "\n\tThe current element must be valid if you are to access it."
                << "\n\tthis: " << this
                );

            return *pos;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        bool array<T,mem_manager>::
        move_next (
        ) const
        {
            if (!_at_start)
            {
                if (pos < last_pos)
                {
                    ++pos;
                    return true;
                }
                else
                {
                    pos = 0;
                    return false;
                }
            }
            else
            {
                _at_start = false;
                if (array_size > 0)
                {
                    pos = array_elements;
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
    //                              Yet more functions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        sort (
        )
        {
            if (this->size() > 1)
            {
                // call the quick sort function for arrays that is in algs.h
                dlib::qsort_array(*this,0,this->size()-1);
            }
            this->reset();
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        resize (
            size_t new_size
        )
        {
            if (this->max_size() < new_size)
            {
                array temp;
                temp.set_max_size(new_size);
                temp.set_size(new_size);
                for (size_t i = 0; i < this->size(); ++i)
                {
                    exchange((*this)[i],temp[i]);
                }
                temp.swap(*this);
            }
            else
            {
                this->set_size(new_size);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        T& array<T,mem_manager>::
        back (
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( this->size() > 0 ,
                          "\tT& array::back()"
                          << "\n\tsize() must be bigger than 0"
                          << "\n\tsize(): " << this->size()
                          << "\n\tthis:   " << this
            );

            return (*this)[this->size()-1];
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        const T& array<T,mem_manager>::
        back (
        ) const
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( this->size() > 0 ,
                          "\tconst T& array::back()"
                          << "\n\tsize() must be bigger than 0"
                          << "\n\tsize(): " << this->size()
                          << "\n\tthis:   " << this
            );

            return (*this)[this->size()-1];
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        pop_back (
            T& item
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( this->size() > 0 ,
                          "\tvoid array::pop_back()"
                          << "\n\tsize() must be bigger than 0"
                          << "\n\tsize(): " << this->size()
                          << "\n\tthis:   " << this
            );

            exchange(item,(*this)[this->size()-1]);
            this->set_size(this->size()-1);
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        pop_back (
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT( this->size() > 0 ,
                          "\tvoid array::pop_back()"
                          << "\n\tsize() must be bigger than 0"
                          << "\n\tsize(): " << this->size()
                          << "\n\tthis:   " << this
            );

            this->set_size(this->size()-1);
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        push_back (
            T& item
        )
        {
            if (this->max_size() == this->size())
            {
                // double the size of the array
                array temp;
                temp.set_max_size(this->size()*2 + 1);
                temp.set_size(this->size()+1);
                for (size_t i = 0; i < this->size(); ++i)
                {
                    exchange((*this)[i],temp[i]);
                }
                exchange(item,temp[temp.size()-1]);
                temp.swap(*this);
            }
            else
            {
                this->set_size(this->size()+1);
                exchange(item,(*this)[this->size()-1]);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename T,
            typename mem_manager
            >
        void array<T,mem_manager>::
        push_back (
            T&& item
        ) { push_back(item); }

    // ----------------------------------------------------------------------------------------

        template <typename T, typename MM>
        struct is_array <array<T,MM> >
        {
            const static bool value = true;
        };

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_ARRAY_KERNEl_2_