dlib C++ Library - array2d_kernel.h

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

    #include "array2d_kernel_abstract.h"
    #include "../algs.h"
    #include "../interfaces/enumerable.h"
    #include "../serialize.h"
    #include "../geometry/rectangle.h"

    namespace dlib
    {
        template <
            typename T,
            typename mem_manager = default_memory_manager
            >
        class array2d : public enumerable<T>
        {

            /*!
                INITIAL VALUE
                    - nc_ == 0
                    - nr_ == 0
                    - data == 0
                    - at_start_ == true
                    - cur == 0
                    - last == 0

                CONVENTION
                    - nc_ == nc()
                    - nr_ == nc()
                    - if (data != 0) then
                        - last == a pointer to the last element in the data array
                        - data == pointer to an array of nc_*nr_ T objects
                    - else
                        - nc_ == 0
                        - nr_ == 0
                        - data == 0
                        - last == 0

                    - nr_ * nc_ == size()
                    - if (cur == 0) then
                        - current_element_valid() == false
                    - else
                        - current_element_valid() == true
                        - *cur == element()

                    - at_start_ == at_start()
            !*/

            class row_helper;
        public:

            // These typedefs are here for backwards compatibility with older versions of dlib.
            typedef array2d kernel_1a;
            typedef array2d kernel_1a_c;

            typedef T type;
            typedef mem_manager mem_manager_type;
            typedef T*          iterator;
            typedef const T*    const_iterator;

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

            class row
            {
                /*!
                    CONVENTION
                        - nc_ == nc()
                        - for all x < nc_:
                            - (*this)[x] == data[x]
                !*/

                friend class array2d<T,mem_manager>;
                friend class row_helper;

            public:
                long nc (
                ) const { return nc_; }

                const T& operator[] (
                    long column
                ) const
                {
                    // make sure requires clause is not broken
                    DLIB_ASSERT(column < nc() && column >= 0,
                        "\tconst T& array2d::operator[](long column) const"
                        << "\n\tThe column index given must be less than the number of columns."
                        << "\n\tthis:    " << this
                        << "\n\tcolumn:  " << column
                        << "\n\tnc(): " << nc()
                    );

                    return data[column];
                }

                T& operator[] (
                    long column
                )
                {
                    // make sure requires clause is not broken
                    DLIB_ASSERT(column < nc() && column >= 0,
                        "\tT& array2d::operator[](long column)"
                        << "\n\tThe column index given must be less than the number of columns."
                        << "\n\tthis:    " << this
                        << "\n\tcolumn:  " << column
                        << "\n\tnc(): " << nc()
                    );

                    return data[column];
                }

            private:

                row(T* data_, long cols) : data(data_), nc_(cols) {}
                row(row&& r) = default;
                row& operator=(row&& r) = default;

                T* data = nullptr;
                long nc_ = 0;

                // restricted functions
                row(const row&) = delete;
                row& operator=(const row&) = delete;
            };

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

            array2d (
            ) :
                data(0),
                nc_(0),
                nr_(0),
                cur(0),
                last(0),
                at_start_(true)
            {
            }

            array2d(
                long rows,
                long cols
            ) :
                data(0),
                nc_(0),
                nr_(0),
                cur(0),
                last(0),
                at_start_(true)
            {
                // make sure requires clause is not broken
                DLIB_ASSERT((cols >= 0 && rows >= 0),
                            "\t array2d::array2d(long rows, long cols)"
                            << "\n\t The array2d can't have negative rows or columns."
                            << "\n\t this: " << this
                            << "\n\t cols: " << cols
                            << "\n\t rows: " << rows
                );

                set_size(rows,cols);
            }

            array2d(const array2d&) = delete;        // copy constructor
            array2d& operator=(const array2d&) = delete;    // assignment operator

    #ifdef DLIB_HAS_RVALUE_REFERENCES
            array2d(array2d&& item) : array2d()
            {
                swap(item);
            }

            array2d& operator= (
                array2d&& rhs
            )
            {
                swap(rhs);
                return *this;
            }
    #endif

            virtual ~array2d (
            ) { clear(); }

            long nc (
            ) const { return nc_; }

            long nr (
            ) const { return nr_; }

            row operator[] (
                long row_
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(row_ < nr() && row_ >= 0,
                    "\trow array2d::operator[](long row_)"
                    << "\n\tThe row index given must be less than the number of rows."
                    << "\n\tthis:     " << this
                    << "\n\trow_:      " << row_
                    << "\n\tnr(): " << nr()
                    );

                return row(data+row_*nc_, nc_);
            }

            const row operator[] (
                long row_
            ) const
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(row_ < nr() && row_ >= 0,
                    "\tconst row array2d::operator[](long row_) const"
                    << "\n\tThe row index given must be less than the number of rows."
                    << "\n\tthis:     " << this
                    << "\n\trow_:      " << row_
                    << "\n\tnr(): " << nr()
                );

                return row(data+row_*nc_, nc_);
            }

            void swap (
                array2d& item
            )
            {
                exchange(data,item.data);
                exchange(nr_,item.nr_);
                exchange(nc_,item.nc_);
                exchange(at_start_,item.at_start_);
                exchange(cur,item.cur);
                exchange(last,item.last);
                pool.swap(item.pool);
            }

            void clear (
            )
            {
                if (data != 0)
                {
                    pool.deallocate_array(data);
                    nc_ = 0;
                    nr_ = 0;
                    data = 0;
                    at_start_ = true;
                    cur = 0;
                    last = 0;
                }
            }

            void set_size (
                long rows,
                long cols
            );

            bool at_start (
            ) const { return at_start_; }

            void reset (
            ) const { at_start_ = true; cur = 0; }

            bool current_element_valid (
            ) const { return (cur != 0); }

            const T& element (
            ) const
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(current_element_valid() == true,
                    "\tconst T& array2d::element()()"
                    << "\n\tYou can only call element() when you are at a valid one."
                    << "\n\tthis:    " << this
                );

                return *cur;
            }

            T& element (
            )
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(current_element_valid() == true,
                             "\tT& array2d::element()()"
                             << "\n\tYou can only call element() when you are at a valid one."
                             << "\n\tthis:    " << this
                );

                return *cur;
            }

            bool move_next (
            ) const
            {
                if (cur != 0)
                {
                    if (cur != last)
                    {
                        ++cur;
                        return true;
                    }
                    cur = 0;
                    return false;
                }
                else if (at_start_)
                {
                    cur = data;
                    at_start_ = false;
                    return (data != 0);
                }
                else
                {
                    return false;
                }
            }

            size_t size (
            ) const { return static_cast<size_t>(nc_) * static_cast<size_t>(nr_); }

            long width_step (
            ) const
            {
                return nc_*sizeof(T);
            }

            iterator begin()
            {
                return data;
            }

            iterator end()
            {
                return data+size();
            }

            const_iterator begin()  const
            {
                return data;
            }

            const_iterator end() const
            {
                return data+size();
            }

        private:

            T* data;
            long nc_;
            long nr_;

            typename mem_manager::template rebind<T>::other pool;
            mutable T* cur;
            T* last;
            mutable bool at_start_;

        };

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

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

        template <
            typename T,
            typename mem_manager
            >
        void serialize (
            const array2d<T,mem_manager>& item,
            std::ostream& out
        )
        {
            try
            {
                // The reason the serialization is a little funny is because we are trying to
                // maintain backwards compatibility with an older serialization format used by
                // dlib while also encoding things in a way that lets the array2d and matrix
                // objects have compatible serialization formats.
                serialize(-item.nr(),out);
                serialize(-item.nc(),out);

                item.reset();
                while (item.move_next())
                    serialize(item.element(),out);
                item.reset();
            }
            catch (serialization_error& e)
            {
                throw serialization_error(e.info + "\n   while serializing object of type array2d");
            }
        }

        template <
            typename T,
            typename mem_manager
            >
        void deserialize (
            array2d<T,mem_manager>& item,
            std::istream& in
        )
        {
            try
            {
                long nr, nc;
                deserialize(nr,in);
                deserialize(nc,in);

                // this is the newer serialization format
                if (nr < 0 || nc < 0)
                {
                    nr *= -1;
                    nc *= -1;
                }
                else
                {
                    std::swap(nr,nc);
                }

                item.set_size(nr,nc);

                while (item.move_next())
                    deserialize(item.element(),in);
                item.reset();
            }
            catch (serialization_error& e)
            {
                item.clear();
                throw serialization_error(e.info + "\n   while deserializing object of type array2d");
            }
        }

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

        template <
            typename T,
            typename mem_manager
            >
        void array2d<T,mem_manager>::
        set_size (
            long rows,
            long cols
        )
        {
            // make sure requires clause is not broken
            DLIB_ASSERT((cols >= 0 && rows >= 0) ,
                   "\tvoid array2d::set_size(long rows, long cols)"
                   << "\n\tThe array2d can't have negative rows or columns."
                   << "\n\tthis: " << this
                   << "\n\tcols: " << cols
                   << "\n\trows: " << rows
            );

            // set the enumerator back at the start
            at_start_ = true;
            cur = 0;

            // don't do anything if we are already the right size.
            if (nc_ == cols && nr_ == rows)
            {
                return;
            }

            nc_ = cols;
            nr_ = rows;

            // free any existing memory
            if (data != 0)
            {
                pool.deallocate_array(data);
                data = 0;
            }

            // now setup this object to have the new size
            try
            {
                if (nr_ > 0)
                {
                    data = pool.allocate_array(nr_*nc_);
                    last = data + nr_*nc_ - 1;
                }
            }
            catch (...)
            {
                if (data)
                    pool.deallocate_array(data);

                data = 0;
                nc_ = 0;
                nr_ = 0;
                last = 0;
                throw;
            }
        }

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

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

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

    }

    #endif // DLIB_ARRAY2D_KERNEl_1_