xsens_fifoqueue.h

Go to the documentation of this file.

#ifndef XSENS_MONOLITHIC

#endif
#ifndef XSENS_FIFOQUEUE_H
#define XSENS_FIFOQUEUE_H


namespace xsens {


template <class T, bool E=true>
class FifoQueue {
protected:
        size_t m_maxCount;
        size_t m_currentCount;
        size_t m_first;
        bool m_deleteOnOverwrite;

        T*      m_list;
public:
        typedef T               value_type;             
        typedef size_t  size_type;              

        FifoQueue(size_type size=16, bool delOnOverwrite = true)
        {
                if (size > 0)
                        m_maxCount = size;
                else
                        m_maxCount = 1;
                m_list = new T[m_maxCount];
                m_currentCount = 0;
                m_first = 0;
                m_deleteOnOverwrite = delOnOverwrite;
        }
        
        template <bool E2>
        FifoQueue(const FifoQueue<T,E2>& q)
        {
                m_maxCount = q.m_maxCount;
                m_list = new T[m_maxCount];
                m_currentCount = q.m_currentCount;
                m_deleteOnOverwrite = q.m_deleteOnOverwrite;
                m_first = 0;
                for (size_t i = 0;i<m_currentCount;++i)
                        m_list[i] = q.m_list[(i+q.m_first) % m_maxCount];
        }
        
        void eraseAndClear(void)
        {
                for (size_t i = 0;i<m_currentCount;++i)
                        delete m_list[(i+m_first) % m_maxCount];
                m_currentCount = 0;
                m_first = 0;
        }

        ~FifoQueue()
        {
                if (E)
                        eraseAndClear();
                m_maxCount = 0;
                delete[] m_list;
        }

        template <bool E2>
        FifoQueue<T,E>& operator=(const FifoQueue<T,E2>& q)
        {
                if (m_maxCount != q.m_maxCount)
                {
                        delete[] m_list;
                        m_maxCount = q.m_maxCount;
                        m_list = new T[m_maxCount];
                }
                m_currentCount = q.m_currentCount;
                m_first = 0;
                for (size_t i = 0;i<m_currentCount;++i)
                        m_list[i] = q.m_list[(i+q.m_first) % m_maxCount];

                return *this;
        }
        
        void resize(const size_t size)
        {
                if (E)
                        eraseAndClear();
                delete[] m_list;
                if (size > 0)
                        m_maxCount = size;
                else
                        m_maxCount = 1;
                m_list = new T[m_maxCount];
                m_currentCount = 0;
                m_first = 0;
        }

        bool empty() const
        {
                return (m_currentCount == 0);
        }
        
        size_type size() const
        {
                return m_maxCount;
        }
        
        size_type length() const
        {
                return m_currentCount;
        }

        value_type& front()
        {
                return m_list[m_first];
        }
        
        const value_type& front() const
        {
                return m_list[m_first];
        }
        
        value_type& back()
        {
                return m_list[(m_first + m_currentCount - 1) % m_maxCount];
        }
        
        const value_type& back() const
        {
                return m_list[(m_first + m_currentCount - 1) % m_maxCount];
        }
        
        void push(const value_type& x)
        {
                if (m_currentCount == m_maxCount)
                {
                        if (m_deleteOnOverwrite)
                                delete m_list[m_first];
                        
                        m_list[m_first] = x;
                        m_first = (m_first+1) % m_maxCount;
                }
                else
                {
                        m_list[(m_first + m_currentCount++) % m_maxCount] = x;
                }
        }

        void pop(void)
        {
                m_first = (m_first+1) % m_maxCount;
                --m_currentCount;
        }

        void popBack(void)
        {
                --m_currentCount;
        }

        const value_type& operator[] (size_t index) const
        {
                if (index >= m_currentCount)
                        return m_list[(m_first + m_currentCount - 1) % m_maxCount];
                else
                        return m_list[(m_first + index) % m_maxCount];
        }

        value_type& operator[] (size_t index)
        {
                if (index >= m_currentCount)
                        return m_list[(m_first + m_currentCount - 1) % m_maxCount];
                else
                        return m_list[(m_first + index) % m_maxCount];
        }

        void clear(void)
        {
                m_currentCount = 0;
                m_first = 0;
        }

        void remove(size_t index)
        {
                if (index >= m_currentCount)
                        return;
                if (index == 0)
                        pop();
                else
                {
                        --m_currentCount;
                        for (size_t i=index;i<m_currentCount;++i)
                                m_list[(m_first + i) % m_maxCount] = m_list[(1 + m_first + i) % m_maxCount];
                }
        }
};



template <class T>
class FifoQueueBasic {
protected:
        size_t m_maxCount;
        size_t m_currentCount;
        size_t m_first;

        T*      m_list;
public:
        typedef T               value_type;             
        typedef size_t  size_type;              

        FifoQueueBasic(size_type size=16)
        {
                if (size > 0)
                        m_maxCount = size;
                else
                        m_maxCount = 1;
                m_list = new T[m_maxCount];
                m_currentCount = 0;
                m_first = 0;
        }
        
        FifoQueueBasic(const FifoQueueBasic<T>& q)
        {
                m_maxCount = q.m_maxCount;
                m_list = new T[m_maxCount];
                m_currentCount = q.m_currentCount;
                m_first = 0;
                for (size_t i = 0;i<m_currentCount;++i)
                        m_list[i] = q.m_list[(i+q.m_first) % m_maxCount];
        }
        
        void eraseAndClear(void)
        {
                for (size_t i = 0;i<m_currentCount;++i)
                        delete m_list[(i+m_first) % m_maxCount];
                m_currentCount = 0;
                m_first = 0;
        }

        ~FifoQueueBasic()
        {
                m_maxCount = 0;
                delete[] m_list;
        }

        FifoQueueBasic<T>& operator=(const FifoQueueBasic<T>& q)
        {
                if (m_maxCount != q.m_maxCount)
                {
                        delete[] m_list;
                        m_maxCount = q.m_maxCount;
                        m_list = new T[m_maxCount];
                }
                m_currentCount = q.m_currentCount;
                m_first = 0;
                for (size_t i = 0;i<m_currentCount;++i)
                        m_list[i] = q.m_list[(i+q.m_first) % m_maxCount];

                return *this;
        }
        
        void resize(const size_t size)
        {
                delete[] m_list;
                if (size > 0)
                        m_maxCount = size;
                else
                        m_maxCount = 1;
                m_list = new T[m_maxCount];
                m_currentCount = 0;
                m_first = 0;
        }

        bool empty() const
        {
                return (m_currentCount == 0);
        }
        
        size_type size() const
        {
                return m_maxCount;
        }
        
        size_type length() const
        {
                return m_currentCount;
        }

        value_type& front()
        {
                return m_list[m_first];
        }
        
        const value_type& front() const
        {
                return m_list[m_first];
        }
        
        value_type& back()
        {
                return m_list[(m_first + m_currentCount - 1) % m_maxCount];
        }
        
        const value_type& back() const
        {
                return m_list[(m_first + m_currentCount - 1) % m_maxCount];
        }
        
        void push(const value_type& x)
        {
                if (m_currentCount == m_maxCount)
                {
                        m_list[m_first] = x;
                        m_first = (m_first+1) % m_maxCount;
                }
                else
                {
                        m_list[(m_first + m_currentCount++) % m_maxCount] = x;
                }
        }

        void push_front(const value_type& x)
        {
                m_first = (m_first+m_maxCount-1)%m_maxCount;
                if (m_currentCount == 0)
                        m_first = 0;
                m_list[m_first] = x;
                if (m_currentCount < m_maxCount)
                        ++m_currentCount;
        }

        void pop(void)
        {
                if (m_currentCount > 0)
                {
                        m_first = (m_first+1) % m_maxCount;
                        --m_currentCount;
                }
        }

        void popBack(void)
        {
                if (m_currentCount > 0)
                        --m_currentCount;
        }

        const value_type& operator[] (size_t index) const
        {
                if (index >= m_currentCount)
                        return m_list[(m_first + m_currentCount - 1) % m_maxCount];
                else
                        return m_list[(m_first + index) % m_maxCount];
        }

        value_type& operator[] (size_t index)
        {
                if (index >= m_currentCount)
                        return m_list[(m_first + m_currentCount - 1) % m_maxCount];
                else
                        return m_list[(m_first + index) % m_maxCount];
        }

        void clear(void)
        {
                m_currentCount = 0;
                m_first = 0;
        }

        void remove(size_t index)
        {
                if (index >= m_currentCount)
                        return;
                if (index == 0)
                        pop();
                else
                {
                        --m_currentCount;
                        for (size_t i=index;i<m_currentCount;++i)
                                m_list[(m_first + i) % m_maxCount] = m_list[(1 + m_first + i) % m_maxCount];
                }
        }
};

} // end of xsens namespace

#endif  // XSENS_FIFOQUEUE_H