be_memory_autoarrayiterator.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to Title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_MEMORY_AUTOARRAYITERATOR_H__
#define __BE_MEMORY_AUTOARRAYITERATOR_H__
 
#include <iterator>
#include <type_traits>
 
namespace BiometricEvaluation
{
        namespace Memory
        {
                template <typename T> class AutoArray;
 
                template <bool C, class T>
                class AutoArrayIterator
                {
                public:
                        /*
                         * Satisfy std::iterator_traits<> expectations.
                         */
 
                        using iterator_category =
                            std::random_access_iterator_tag;
                        using value_type = typename
                            std::conditional<C, const T, T>::type;
                        using difference_type = std::ptrdiff_t;
                        using pointer = typename
                            std::conditional<C, const T*, T*>::type;
                        using reference = typename
                            std::conditional<C, const T&, T&>::type;
 
                        using container = typename std::conditional<C,
                            const AutoArray<T>*, AutoArray<T>*>::type;
 
                        /*
                         * Constructors
                         */
 
                        AutoArrayIterator(
                            container autoArray = nullptr,
                            difference_type offset = 0) :
                            _autoArray(autoArray),
                            _offset(offset)
                        {
 
                        }
 
                        AutoArrayIterator(
                            const AutoArrayIterator &rhs) = default;
                        AutoArrayIterator(
                            AutoArrayIterator &&rhs) = default;
                        ~AutoArrayIterator() = default;
 
                        /*
                         * Assignments
                         */
 
                        inline AutoArrayIterator&
                        operator=(
                            pointer rhs)
                        {
                                _offset = rhs;
                                return (*this);
                        }
 
                        inline AutoArrayIterator&
                        operator=(
                            const AutoArrayIterator &rhs) = default;
 
                        inline AutoArrayIterator&
                        operator+=(
                            const difference_type &rhs)
                        {
                                _offset += rhs;
                                return (*this);
                        }
 
                        inline AutoArrayIterator&
                        operator-=(
                            const difference_type &rhs)
                        {
                                _offset -= rhs;
                                return (*this);
                        }
 
                        /*
                         * Dereferencing Content
                         */
 
                        inline reference
                        operator*()
                            const
                        {
                                return (_autoArray->operator[](_offset));
                        }
 
                        inline pointer
                        operator->()
                            const
                        {
                                return (&(_autoArray->operator[](_offset)));
                        }
 
                        inline reference
                        operator[](
                            const difference_type &rhs)
                            const
                        {
                                return (_autoArray->operator[](rhs));
                        }
 
                        /* 
                         * Arithmetic
                         */
 
                        inline AutoArrayIterator&
                        operator++()
                        {
                                ++_offset;
                                return (*this);
                        }
 
                        inline AutoArrayIterator&
                        operator--()
                        {
                                --_offset;
                                return (*this);
                        }
 
                        inline AutoArrayIterator
                        operator++(
                            int)
                        {
                                const AutoArrayIterator previous(*this);
                                ++(*this);
                                return (previous);
                        }
 
                        inline AutoArrayIterator
                        operator--(
                            int)
                        {
                                AutoArrayIterator previous(*this);
                                --(*this);
                                return (previous);
                        }
 
                        inline AutoArrayIterator
                        operator+(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (AutoArrayIterator(_offset +
                                    rhs._offset));
                        }
 
                        inline difference_type
                        operator-(
                            const AutoArrayIterator<C, T> &rhs)
                            const
                        {
                                return (_offset - rhs._offset);
                        }
 
                        inline AutoArrayIterator
                        operator+(
                            const difference_type &rhs)
                            const
                        {
                                return (AutoArrayIterator(_autoArray,
                                    _offset + rhs));
                        }
 
                        inline AutoArrayIterator
                        operator-(
                            const difference_type &rhs)
                            const
                        {
                                return (AutoArrayIterator(_autoArray,
                                    _offset - rhs));
                        }
 
                        friend inline AutoArrayIterator
                        operator+(
                            const difference_type &lhs,
                            const AutoArrayIterator &rhs)
                        {
                                return (AutoArrayIterator(rhs._autoArray,
                                    lhs + rhs._offset));
                        }
 
                        friend inline AutoArrayIterator
                        operator-(
                            const difference_type &lhs,
                            const AutoArrayIterator &rhs)
                        {
                                return (AutoArrayIterator(rhs._autoArray,
                                    lhs - rhs._offset));
                        }
 
                        /*
                         * Comparisons
                         */
 
                        inline bool
                        operator==(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset == rhs._offset);
                        }
 
                        inline bool
                        operator!=(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset != rhs._offset);
                        }
 
                        inline bool
                        operator>(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset > rhs._offset);
                        }
 
                        inline bool
                        operator<(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset < rhs._offset);
                        }
 
                        inline bool
                        operator>=(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset >= rhs._offset);
                        }
 
                        inline bool
                        operator<=(
                            const AutoArrayIterator &rhs)
                            const
                        {
                                return (_offset <= rhs._offset);
                        }
 
                private:
                        container _autoArray;
                        difference_type _offset;
                };
        }
}
 
#endif /* __BE_MEMORY_AUTOARRAYITERATOR_H__ */