STL list

/*
*
* Copyright (c) 2016 hujian.
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
* file: hjstl_list.h 
* Author:hujian
* Time:2016/4/18
*/
#ifndef  _HJSTL_LIST_H_
#define  _HJSTL_LIST_H_

#include "hjstl_alloc.h"
#include "hjstl_iterator.h"
#include "hjstl_construct.h"
#include "hjstl_uninitialized.h"

#define _HJSTL_LIST_PUBLIC_  public
#define _HJSTL_LIST_PRIVATE_ private 
#define _HJSTL_LIST_PROTECTED_ protected


//this is the list node structure
template<class Type>
struct __hjstl_list_node{
    typedef void* void_pointer;//this is the pointer type.
    void_pointer  next;//the next pointer
    void_pointer  prev;//the prev pointer
    Type          data;//this is the node's data
};

//so,this is the list iterator,and the list's iterator is 
//bidirectional type's iterator.
template<class Type,class Reference,class Pointer>
struct __hjstl_list_iterator{
    //some typedefs
    typedef __hjstl_list_iterator<Type, Type&, Type*>  iterator;
    typedef __hjstl_list_iterator<Type, const Type&, const Type*> const_iterator;
    typedef __hjstl_list_iterator<Type, Reference, Pointer> self;

    typedef hjstl_bidirectional_iterator_tag iterator_category;
    typedef Type    value_type;
    typedef Pointer pointer;
    typedef Reference reference;
    typedef __hjstl_list_node<Type>* link_type;
    typedef size_t size_type;
    typedef ptrdiff_t  difference_type;

    //this is the pointer to pointer to the node.
    //and the node will store the infomation of node.
    link_type  hjstl_list_node;

    //the follow def is construct
    __hjstl_list_iterator(link_type x) :hjstl_list_node(x){}
    __hjstl_list_iterator(){}
    __hjstl_list_iterator(const iterator& x) :hjstl_list_node(x.hjstl_list_node){}

    //overload....
    bool operator==(const self&x) const { return hjstl_list_node == x.hjstl_list_node; }
    bool operator!=(const self&x) const { return hjstl_list_node != x.hjstl_list_node; }

    //get the iterator's value.
    reference operator*()const { return (*hjstl_list_node).data; }
    pointer   operator->()const{ return &(operator*()); }

    //increase the iterator,get the next iterator
    //++iterator
    self& operator++(){
        hjstl_list_node = (link_type)((*hjstl_list_node).next);
        return *this;
    }
    //iterator++
    self operator++(int){
        self tmp = *this;
        ++(*this);
        return tmp;
    }

    //deincrease the iterator,and get the prev iterator
    //iterator--
    self& operator--(){
        hjstl_list_node = (link_type)((*hjstl_list_node).prev);
        return *this;
    }

    //iterator--
    self operator--(int){
        self tmp = *this;
        --(*this);
        return tmp;
    }

};//end of list iterator


template<class Type,class Ref,class Ptr>
inline hjstl_bidirectional_iterator_tag
iterator_category(const __hjstl_list_iterator<Type, Ref, Ptr>&){
    return _HJSTL_bidirectional_iterator();
}

template<class Type,class Ref,class Ptr>
inline Type* 
hjstl_value_type(const __hjstl_list_iterator<Type, Ref, Ptr>&){
    return 0;
}

template<class Type,class Ref,class Ptr>
inline ptrdiff_t*
distance_type(const __hjstl_list_iterator<Type, Ref, Ptr>&){
    return 0;
}


//this is the list class
//the default allocate is the memory pool.
template<class Type,class Alloc=HJSTL_Alloc::Alloc_second>
class _HJSTL_list{
//_HJSTL_LIST_PROTECTED_:
    __HJSTL_PUBLIC_:
    typedef void* void_pointer;
    typedef __hjstl_list_node<Type> list_node;
    //the alloc.....
    typedef _HJSTL_simple_alloc<list_node, Alloc> hjstl_list_node_allocator;

__HJSTL_PUBLIC_:
    typedef Type   value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef list_node* link_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;


    //so,this node will manage all list.
    //because the list is double list,so,just one pointer needed.
    link_type this_node;
    test
    void* test_ptr;
    //the iterator of this list
    typedef __hjstl_list_iterator<Type, Type&, Type*>     iterator;
    typedef __hjstl_list_iterator<Type, const Type&, const Type*>   const_iterator;

//_HJSTL_LIST_PROTECTED_:
    _HJSTL_LIST_PUBLIC_:
    //alloc an node,and return the node
    link_type get_node(){
        return hjstl_list_node_allocator::allocate();
    }
    //free an node
    void     put_node(link_type p){
        hjstl_list_node_allocator::deallocate(p);
    }

    //create an new node,and with value
    link_type create_node(const Type& v){
        link_type p = get_node();
        try{
            construct(&p->data, v);
        }
        catch (...){
            //if error,free the node
            put_node(p);
        }
        return p;
    }

    //destroy an node
    void destroy_node(link_type p){
        destroy(&p->data);
        put_node(p);
    }

    //the initialze function,just set up the double circle list
    void _empty_initialze(){
        //circle and double director
        this_node = get_node();
        this_node->next = this_node;
        this_node->prev = this_node;
    }

    //create n node,and initialze with value
    void _fill_initialze(size_type n,const Type& value){
        //set up the list
        _empty_initialze();
        try{
            //insert node,and init the value
            insert(begin(), n, value);
        }
        catch (...){
            clear();
            put_node(this_node);
        }
    }

    //range initialze
    void range_initialze(const Type* first, const Type* last){
        //set up
        _empty_initialze();
        try{
            insert(begin(), first, last);
        }
        catch (...){
            clear();
            destroy_node(this_node);
        }
    }



    //set up the list
    _HJSTL_list() { _empty_initialze(); }

    _HJSTL_list(size_type n, const Type& value){ _fill_initialze(n, value); }
    _HJSTL_list(int n, const Type&value){ _fill_initialze(n, value); }
    _HJSTL_list(long n, const Type& value){ _fill_initialze(n, value); }
    _HJSTL_list(size_type n){ _fill_initialze(n, Type()); }
    _HJSTL_list(const Type* first, const Type* last){range_initialze(first, last);}
    _HJSTL_list(const _HJSTL_list<Type, Alloc>& x){range_initialze(x.begin(), x.end());}


    //the list's transfer.very magic function but so easy to write
    //move the [first,last) to before position
    void transfer(iterator position, iterator first, iterator last)
    {
        if (position != last)
        {
            (*(link_type((*last.hjstl_list_node).prev))).next = position.hjstl_list_node;
            (*(link_type((*first.hjstl_list_node).prev))).next = last.hjstl_list_node;
            (*(link_type((*position.hjstl_list_node).prev))).next = first.hjstl_list_node;

            link_type tmp = link_type((*position.hjstl_list_node).prev);
            (*position.hjstl_list_node).prev = (*last.hjstl_list_node).prev;
            (*last.hjstl_list_node).prev = (*first.hjstl_list_node).prev;
            (*first.hjstl_list_node).prev = tmp;
        }
    }

    //splice
    //different list
    void splice(iterator position, _HJSTL_list& x)
    {
        if (!x.empty()){
            transfer(position, x.begin(), x.end());
        }
    }
    //same list
    void splice(iterator position, _HJSTL_list&, iterator i)
    {
        iterator j = i;
        ++j;
        if (position == i || position == j){
            return;
        }
        transfer(position, i, j);
    }

    void splice(iterator position, _HJSTL_list&, iterator first, iterator last)
    {
        if (first != last){
            transfer(position, first, last);
        }
    }

    //remove the value.
    void remove(const Type& value)
    {
        iterator first = begin();
        iterator last = end();
        while (first != last){
            iterator next = first;
            ++next;//move to next,no influence the list operator<traversal>
            if (*first == value) erase(first);
            first = next;
        }
    }

    //unique
    //this is about algorithm
    void unique()
    {
        iterator first = begin();
        iterator last = end();
        if (first == last) return;
        iterator next = first;
        while (++next != last){
            if (*first == *next){
                erase(next);
            }
            else{
                first = next;
            }
            next = first;
        }
    }

    //merge,you need to ensure the two list has sorted
    void merge(_HJSTL_list& x)
    {
        iterator first1 = begin();
        iterator last1 = end();

        iterator first2 = x.begin();
        iterator last2 = x.end();
        while (first1 != last1&&first2 != last2)
        {
            if (*first2 < *first1){
                iterator next = first2;
                //only first2 will be moved to---> ...[first2][first1]...
                transfer(first1, first2, ++next);
                first2 = next;
            }
            else{
                ++first1;
            }
            if (first2 != last2){
                //more data
                transfer(last1, first2, last2);
            }
        }
    }

    //reserve the list
    //this is magic...
    void reserve()
    {
        //judge if this is a empty list,or just one elements
        if (this_node->next == this_node ||
            link_type(this_node->next)->next == this_node){
            return;
        }
        iterator first = begin();
        ++first;
        while (first != end()){
            iterator old = first;
            ++first;
            //only one elements will be moved
            transfer(begin(), old, first);
        }
    }

    //sort this list
    //quick sort
    void sort()
    {
        //judge wether this list only one element or empty
        if (this_node->next == this_node ||
            ((link_type)(this_node->next))->next == this_node){
            return;
        }
        _HJSTL_list<Type, Alloc> carry;
        _HJSTL_list<Type, Alloc> counter[64];
        int fill = 0;
        while (!empty())
        {
            carry.splice(carry.begin(), *this, begin());
            int i;
            while (i < fill&&!counter[i].empty()){
                counter[i].merge(carry);
                carry.swap(counter[i++]);
            }
            carry.swap(counter[i]);
            if (i == fill) ++fill;
        }
        for (int i = 0; i < fill; i++){
            counter[i].merge(counter[i - 1]);
        }
        swap(counter[fill - 1]);
    }

    //get the begin iterator
    iterator begin(){
        //cause the this_node is the flag of this list
        //so,the this_node is empty forever
        return (link_type)((*this_node).next);
    }

    //get the end iterator
    iterator end(){
        //and this is empty.
        return ((this_node));
    }

    //is empty?
    bool empty(){
        return this_node->next == this_node;
    }

    //the size of this list
    size_type size(){
        size_type result = 0;
        hjstl_distance(begin(), end(), result);
        return result;
    }

    //the max size
    size_type max_size() const{
        return size_type(-1);
    }

    //get the front's value
    reference front(){
        return *begin();
    }

    //get the back
    reference back(){
        return *(--end());
    }

    //swap
    void swap( _HJSTL_list<Type, Alloc>&x ){
        swap(this_node, x);
    }

    //insert a node,before position...
    iterator insert(iterator position, const Type& v)
    {
        /*
          before insert
          ....[]-[]-[position]-[]-[]-[].....

          running
          ....[]-[]-[position]-[]-[]-[]......
                    -[tmp]-
          after insert
          ....[]-[]-[tmp]-[position]-[]-[]-[]......
        */
        //this is the node will insert
        link_type tmp = create_node(v);
        tmp->next = position.hjstl_list_node;
        tmp->prev = position.hjstl_list_node->prev;
        ((link_type)(position.hjstl_list_node->prev))->next = tmp;
        position.hjstl_list_node->prev = tmp;
        return tmp;
    }

    //insert null before position
    iterator insert(iterator position){
        return insert(position, Type());
    }
    ///push....
    void push_front(const Type& v){ insert(begin(), v); }
    void push_back(const Type& v){ insert(end(), v); }

    //pop...
    void pop_front(){erase(begin());}
    void pop_back(){
        iterator tmp = end();
        erase(--tmp);
    }
    template<class InputIterator>
    void insert(iterator position, InputIterator first, InputIterator last)
    {
        for (; first != last; ++first){
            insert(position, *first);
        }
    }
    void insert(iterator position, const Type* first, const Type* last)
    {
        for (; first != last; ++first){
            insert(position, *first);
        }
    }

    void insert(iterator position, const_iterator first, const_iterator last)
    {
        for (; first != last; ++first){
            insert(position, *first);
        }
    }

    void insert(iterator pos, size_type n, const Type& x)
    {
        for (; n > 0; --n){
            insert(pos, x);
        }
    }
    void insert(iterator pos, int n, const Type& x)
    {
        insert(pos, (size_type)n, x);
    }
    void insert(iterator pos, long n, const Type& x)
    {
        insert(pos, (size_type)n, x);
    }

    //erase
    iterator erase(iterator position)
    {
        /*
            before erase
            ...[]-[position]-[]...
            running
            ...[]-...-[]...
            after
            ...[]-[]...
        */
        link_type next_node = link_type(position.hjstl_list_node->next);
        link_type prev_node = link_type(position.hjstl_list_node->prev);

        prev_node->next = next_node;
        next_node->prev = prev_node;
        //destroy this node
        destroy_node(position.hjstl_list_node);
        return iterator(position.hjstl_list_node);
    }


    //another erase function
    //[first,last)
    iterator erase(iterator first, iterator last)
    {
        //erase range...iterators
        while (first != last){
            erase(first++);
        }
        return last;
    }

    //resize
    void resize(size_type new_szie, const Type& v)
    {
        iterator it = begin();
        size_type len = 0;
        for (; it != end() && len < new_szie; i++, len++);
        //more space left
        if (len == new_szie){
            erase(it, end());
        }
        else{//no so many nodes.
            insert(end(), new_szie - len, v);
        }
    }
    //resize and no initialze
    void resize(size_type new_size){ resize(new_size, Type()); }



    //clear the list
    void clear()
    {
        //this_node is the flag,and it's null
        link_type curr = (link_type)this_node->next;
        while (curr != this_node){
            link_type tmp = curr;
            curr = (link_type)curr->next;
            destroy_node(tmp);
        }
        //reset the list
        this_node->next = this_node;
        this_node->prev = this_node;
    }

    //operator =
    _HJSTL_list<Type, Alloc>& operator=(const _HJSTL_list<Type, Alloc>& x)
    {
        //if same obj,just return
        if (this != &x){
            iterator first1 = begin();
            iterator last1 = end();

            const_iterator first2 = x.begin();
            const_iterator last2 = x.end();

            while (first1 != last1&&first2 != last2){
                *first1++ = *first2++;
            }
            //check
            if (first2 == last2){
                //more....
                erase(first1, last1);
            }
            else{//no so many nodes,so insert some empty nodes
                insert(last1, first2, last2);
            }
        }
        return *this;
    }
    //deconstruct
    ~_HJSTL_list()
    {
        clear();
        put_node(this_node);
    }
};//end of hjstl list

#endif  //end of _HJSTL_LIST_H_