list.hpp

#ifndef QOS_CPP_LIST
#define QOS_CPP_LIST
 
#include "include/types.hpp"
 
namespace qOS {


    enum listPosition : int32_t {
        AT_FRONT = -1,
        AT_BACK = -2
    };
 
    class list;
    class node {
        private:
            node *next{ nullptr };
            node *prev{ nullptr };
            list *container{ nullptr };
            void init( void ) noexcept;
            node( node const& ) = delete;
            void operator=( node const& ) = delete;
        public:
            inline list* getContainer( void ) const noexcept
            {
                /*cstat -CONST-member-ret -MISRAC++2008-9-3-1*/
                return container;
                /*cstat +CONST-member-ret +MISRAC++2008-9-3-1*/
            }
            node() noexcept : next(nullptr), prev(nullptr), container(nullptr) {}
            virtual ~node() {}
 
        friend class list;
        friend class listIterator;
    };

    using listCompareFcn_t = bool (*)( const void *, const void * );

    enum class listDirection {
        FORWARD,
        BACKWARD
    };
 
    class listIterator;

    class list : protected node {
        private:
            node *head{ nullptr };
            node *tail{ nullptr };
            size_t size{ 0U };
            bool isMember( const void * const xNode ) const noexcept;
            void insertAtFront( node * const xNode ) noexcept;
            void insertAtBack( node * const xNode ) noexcept;
            node* removeFront( void ) noexcept;
            node* removeBack( void ) noexcept;
            node* getNodeAtIndex( const listPosition p ) const noexcept;
            void givenNodeSwapBoundaries( node *n1, node *n2 ) noexcept;
            static void givenNodeSwapAdjacent( node *n1, node *n2 ) noexcept;
            static void givenNodesUpdateOuterLinks( node *n1, node *n2 ) noexcept;
            list( list const& ) = delete;
            void operator=( list const& ) = delete;
        public:
            list() noexcept;
            virtual ~list() {}
            bool insert( void * const xNode, const listPosition p = listPosition::AT_BACK ) noexcept;
            bool remove( void * const xNode ) noexcept;
            void* remove( const listPosition p, void * const xNode = nullptr ) noexcept;
            void* getFront( void ) const noexcept;
            void* getBack( void ) const noexcept;
            bool isEmpty( void ) const noexcept;
            size_t length( void ) const noexcept;
            bool sort( listCompareFcn_t f ) noexcept;
            bool swap( void* node1, void* node2 ) noexcept;
            bool move( list& src, const listPosition p = listPosition::AT_BACK ) noexcept;
            void clean( void ) noexcept;
            listIterator begin( void ) noexcept;
            listIterator end( void ) noexcept;
            listIterator from( void *offset ) noexcept;
            explicit operator bool() const noexcept {
                return ( nullptr != head );
            }
        friend class listIterator;
    };

    class listIterator {
        private:
            list *l{ nullptr };
            node *iter{ nullptr };
            void *current{ nullptr };
        public:
            listIterator() = delete;
            virtual ~listIterator() {}
            explicit listIterator( list& xList, listDirection dir = listDirection::FORWARD, void *nodeOffset = nullptr ) noexcept;
            bool untilEnd( void ) const noexcept;
            bool untilEnd( void* node ) const noexcept;
            listIterator& operator++( int ) noexcept;
            listIterator& operator--( int ) noexcept;
            template <typename T>
            inline T get( void ) noexcept
            {
                /*cstat -CERT-EXP36-C_b*/
                return static_cast<T>( current );
                /*cstat +CERT-EXP36-C_b*/
            }
    };

}
 
#endif /*QOS_CPP_LIST*/