BaseList.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//


#ifndef CMR_BASE_LIST_INCLUDED
#define CMR_BASE_LIST_INCLUDED

#include "Allocator.h"

namespace commore
{
    struct BaseListNode;
    struct BaseListNodeRoot;

    class CMREXD BaseList
    {
    public:

        class iterator;
        class const_iterator;
        class CMREXD iterator
        {
            friend class BaseList;
            friend class const_iterator;

        public:
            iterator();
            iterator(const iterator& original);
            operator bool () const;

            bool  more() const;
            iterator& operator++();
            iterator  operator++(int);
            iterator& operator--();
            iterator operator--(int);
            Byte* get_data() const;
            Dummy& get_dummy() const;
            bool  operator==(const iterator& iter) const;
            bool  operator!=(const iterator& iter) const;

        protected:
            iterator(BaseListNode* node, BaseList* cont);
            BaseList& cont();

        protected:
            BaseListNode* node_;
            BaseList* cont_;
        };
        friend class iterator;

        class CMREXD const_iterator
        {
            friend class BaseList;
            friend class iterator;

        public:
            const_iterator();
            const_iterator(const iterator& original);
            const_iterator(const const_iterator& original);
            
            operator bool () const;
        public:
            bool  more() const;
            const_iterator& operator++();
            const_iterator operator++(int);
            const_iterator& operator--();
            const_iterator  operator--(int);
            bool  operator==(const const_iterator& iter) const;
            bool  operator!=(const const_iterator& iter) const;

        protected:
            const_iterator(const BaseListNode* node, const BaseList* cont);

        protected:
            const Byte* get_data() const;
            const Dummy& get_dummy() const;
            const BaseList& cont() const;

        protected:
            const BaseListNode* node_;
            const BaseList* cont_;
        };
        friend class const_iterator;


    public:
        BaseList();
        ~BaseList();
    public: 
        iterator  begin();
        iterator  end();
        const_iterator  begin() const;
        const_iterator  end() const;
        const_iterator cbegin() const;
        const_iterator cend() const;

        iterator  insert(iterator pos, size_t size, FunctionConstructor c, const Byte* value = 0);
        iterator  insert(size_t pos, size_t size, FunctionConstructor c, const Byte* value = 0);
        void  insert(iterator pos, const_iterator first, const_iterator last, size_t size, FunctionConstructor c);
        Byte* push_back_once(size_t size, FunctionConstructor ctor, FunctionComparator cmor, const Byte* value);
        Byte* push_back(size_t size, FunctionConstructor ctor, const Byte* value = 0);
        bool  find(const Byte* value, FunctionComparator cmor) const;
        bool  find(FunctionFilter filter) const;
        int  compare(const BaseList& l, FunctionComparator cmor) const;
        void  assign(const_iterator first, const_iterator last, FunctionConstructor c, FunctionDestructor d, size_t size);

        BaseListNodeRoot* allocate_root_node_();
        BaseListNode* allocate_node_(size_t size, FunctionConstructor c, const Byte* value = 0);
        void deallocate_node_(BaseListNodeRoot* node);
        void deallocate_node_(BaseListNode* node, FunctionDestructor d);
        void init_root();
        void clear(FunctionDestructor d);
        iterator erase(iterator pos, FunctionDestructor d);
        iterator erase(iterator first, iterator last, FunctionDestructor d);
        iterator get_at(size_t i);
        const_iterator get_at(size_t i) const;
        bool remove_at(size_t i, FunctionDestructor d);
        BaseList& swap(BaseList& original);
        BaseList& splice(iterator pos, BaseList& original);
        BaseList& splice(BaseList& original, FunctionDestructor d);
        BaseList& splice(iterator pos, BaseList& original, iterator i);
        BaseList& remove(const Byte* v, FunctionComparator cmor, FunctionDestructor d);
        BaseList& merge(BaseList& original, FunctionComparator cmor);
        BaseList& sort(FunctionComparator cmor);

        BaseList& unique(FunctionComparator cmor, FunctionDestructor d);
        BaseList& remove_ptr(const Byte* v, FunctionDestructor d);
        BaseList& remove_if(FunctionFilter filter, FunctionDestructor d);
        BaseList& reverse();
        size_t size() const
        {
            return length_;
        }
        bool empty() const
        {
            return length_ == 0;
        }

    public:
        static  void move_before(iterator pos, iterator i);
        static  void move_after(iterator pos, iterator i);
        static  void transfer(iterator pos, iterator first, iterator last);


        static  int comparator_(const Byte* v1, const Byte* v2, size_t size);
        static  void constructor_(Byte* data, const Byte* value, size_t size);
        static  void destructor_(Byte* data);

    private:
        BaseListNodeRoot* root_;
        size_t length_;
    };
}


#endif