List.h

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


#ifndef CMR_LIST_INCLUDED
#define CMR_LIST_INCLUDED

#include "BaseList.h"

namespace commore
{
    template< class T, class A> class  List : public BaseList
    {
    public:
        class iterator : public BaseList::iterator
        {
            // seems needed for old VC6 on windows ... probably a compiler bug!
            typedef BaseList::iterator super;
        public:
            iterator(const BaseList::iterator& i) : super(i) {}
        public:
            T& operator *()
            {
                return *(T*)get_data();
            }
            List<T, A>& cont()
            {
                return (List<T, A>&)super::cont();
            }
            iterator& erase()
            {
                *this = cont().erase(*this);
                return *this;
            }
            iterator& insert(const T& v)
            {
                iterator i = cont().insert(*this, v);
                i++;
                *this = i;
                return *this;
            }
            T& insert()
            {
                iterator i = cont().insert(*this);
                T& r = *i;
                i++;
                *this = i;
                return r;
            }
            iterator& add(const T& v)
            {
                iterator i = *this;
                i++;
                *this = cont().insert(i, v);
                return *this;
            }
            T& add()
            {
                iterator i = *this;
                i++;
                *this = cont().insert(i);
                return **this;
            }
        };

        class const_iterator : public BaseList::const_iterator
        {
            // seems needed for old VC6 on windows ... probably a compiler bug!
            typedef BaseList::const_iterator super;
        public:
            const_iterator(const super& i)
                : super(i)
            {}

        public:
            const T& operator *()
            {
                return *(const T*)get_data();
            }
        };

    public:
        List() {}
        List(const  List<T, A>& original)
        {
            insert(begin(), original.begin(), original.end());
        }
        List<T, A>& operator=(const  List<T, A>& l)
        {
            return assign(l.begin(), l.end());
        }
        ~List()
        {
            clear();
        }

    public:
        typedef T value_type;

    public:

        iterator begin()
        {
            return (iterator)BaseList::begin();
        }
        iterator end()
        {
            return (iterator)BaseList::end();
        }
        const_iterator begin() const
        {
            return (const_iterator)BaseList::begin();
        }
        const_iterator end() const
        {
            return (const_iterator)BaseList::end();
        }
        const_iterator cbegin() const 
        {
            return begin();
        }
        const_iterator cend() const
        {
            return end();
        }

        T& front()
        {
            return *begin();
        }
        const T& front() const
        {
            return *begin();
        }
        T& back()
        {
            return *(--end());
        }
        const T& back() const
        {
            return *(--end());
        }
        iterator insert(iterator pos, const T& value)
        {
            return BaseList::insert(pos, sizeof(T), A::constructor, (const Byte*)&value);
        }
        iterator insert(iterator pos)
        {
            return BaseList::insert(pos, sizeof(T), A::constructor);
        }
        iterator insert(size_t pos, const T& value)
        {
            return BaseList::insert(pos, sizeof(T), A::constructor, (const Byte*)&value);
        }
        iterator insert(size_t pos)
        {
            return BaseList::insert(pos, sizeof(T), A::constructor);
        }
        void  insert(iterator pos, const_iterator first, const_iterator last)
        {
            BaseList::insert(pos, first, last, sizeof(T), A::constructor);
        }
        void  push_back(const T& value)
        {
            BaseList::insert(BaseList::end(), sizeof(T), A::constructor, (const Byte*)&value);
        }
        void  push_front(const T& value)
        {
            insert(begin(), value);
        }
        void  pop_front()
        {
            BaseList::erase(begin(), A::destructor);
        }
        void  pop_back()
        {
            iterator tmp = end();
            BaseList::erase(--tmp , A::destructor);
        }
        T&  push_back_once(const T& value)
        {
            return *(T*)BaseList::push_back_once(sizeof(T), A::constructor, A::comparator, (const Byte*)&value);
        }
        T& add()
        {
            BaseList::iterator pos = BaseList::end();
            Byte* data = BaseList::insert(pos, sizeof(T), A::constructor).get_data();
            return *(T*)data;
        }
        T& add(const T& value)
        {
            return *(T*)BaseList::insert(BaseList::end(), sizeof(T), A::constructor, (const Byte*)&value).get_data();
        }
        bool remove_at(size_t i)
        {
            return BaseList::remove_at(i, A::destructor);
        }
        iterator erase(iterator pos)
        {
            return (iterator)BaseList::erase(pos, A::destructor);
        }
        iterator erase(iterator first, iterator last)
        {
            return (iterator)BaseList::erase(first, last, A::destructor);
        }
        List<T, A>& remove(const T& value)
        {
            return (List<T, A>&)BaseList::remove((const Byte*)&value, A::comparator, A::destructor);
        }
        List<T, A>& remove(const T* pvalue)
        {
            return (List<T, A>&)BaseList::remove((const Byte*)pvalue, A::comparator, A::destructor);
        }
        List<T, A>& remove_if(bool (*pred)(const T&))
        {
            return (List<T, A>&)BaseList::remove((FunctionFilter)pred, A::destructor);
        }
        List<T, A>& unique()
        {
            return (List<T, A>&)BaseList::unique(A::comparator, A::destructor);
        }
        List<T, A>& unique(int (*pred)(const T&, const T&))
        {
            return (List<T, A>&)BaseList::unique((FunctionComparator)pred, A::destructor);
        }
        List<T, A>& merge(List<T, A>& original)
        {
            return merge(original, A::compare);
        }
        List<T, A>& merge(List<T, A>& original, int (*comp)(const T&, const T&))
        {
            return (List<T, A>&)BaseList::merge(original, (FunctionComparator)comp);
        }
        List<T, A>& sort()
        {
            return (List<T, A>&)BaseList::sort(A::comparator);
        }
        List<T, A>& sort(int (*comp)(const T&, const T&))
        {
            return (List<T, A>&)BaseList::sort((FunctionComparator)comp);
        }
        List<T, A>& reverse()
        {
            return (List<T, A>&)BaseList::reverse();
        }
        const_iterator get_at(size_t i) const
        {
            return (const_iterator)BaseList::get_at(i);
        }
        iterator get_at(size_t i)
        {
            return (iterator)BaseList::get_at(i);
        }
        bool find(const T& value) const
        {
            return BaseList::find((const Byte*)&value, A::comparator);
        }
        bool find(bool (*pred)(const T&)) const
        {
            return BaseList::find((FunctionFilter)pred);
        }
        int compare(const  List<T, A>& l) const
        {
            return BaseList::compare(l, A::comparator);
        }
        bool operator== (const  List<T, A>& l) const
        {
            return BaseList::compare(l, A::comparator) == 0;
        }
        bool operator< (const  List<T, A>& l) const
        {
            return BaseList::compare(l, A::comparator) < 0;
        }
        bool operator> (const  List<T, A>& l) const
        {
            return BaseList::compare(l, A::comparator) > 0;
        }
        
        List<T, A>& assign(const_iterator first, const_iterator last)
        {
            BaseList::assign(first, last, A::constructor, A::destructor, sizeof(T));
            return *this;
        }
        List<T, A>& swap(List<T, A>& original)
        {
            return (List<T, A>&)BaseList::swap(original);
        }
        List<T, A>& splice(List <T, A>& original)
        {
            return (List<T, A>&)BaseList::splice(original, A::destructor);
        }
        List<T, A>& splice(iterator pos, List <T, A>& original)
        {
            return (List<T, A>&)BaseList::splice(pos, original);
        }
        void clear()
        {
            BaseList::clear(A::destructor);
        }

        // TODO: currently commented because do not work with old VC6 compiler !
        // example: provide a conversion from List<T, CmrListAllocator<Tuple>> to List<Tuple, CmrListAllocator<Tuple>>, where T extends Tuple
        /*
        typedef A::value_type allocated_value_type;
        operator List<typename allocated_value_type, A>&() { return (List<typename allocated_value_type, A>&)(*this); }
        operator const List<typename allocated_value_type, A>&() { return (const List<typename allocated_value_type, A>&)(*this); }
        */
        CMREXD long  read_xml(IBStream& i);
        CMREXD long  write_xml(OBStream& o) const;
        CMREXD int   write(const Path& file) const;
        CMREXD int   read(const Path& file);
        CMREXD int   write_xml(const Path& file) const;
        CMREXD int   read_xml(const Path& file);
        CMREXD AString& to_xml_string(AString& s) const;
        CMREXD  long  from_xml_string(const AString& s);

    public:
        static void  transfer(iterator pos, iterator first, iterator last)
        {
            BaseList::transfer(pos, first, last);
        }

    };
}

inline bool __trueset(bool& b, bool v)
{
    b = v;
    return true;
}

#define cmr_foreach(T, V, L) \
    if (bool continue__ = true) \
        for (commore::List<T>::iterator i__ = L.begin(); continue__ && i__; i__++) \
            if (bool b__ = true) if (__trueset(continue__, false)) \
                    for (T& V = *i__;b__; b__ = false,continue__ = true)

#define cmr_const_foreach(T, V, L) \
    if (bool continue__ = true) \
        for (commore::List<T>::const_iterator i__ = L.begin(); continue__ && i__; i__++) \
            if (bool b__ = true) if (__trueset(continue__, false)) \
                    for (const T& V = *i__;b__; b__ = false,continue__ = true)


#define cmr_foreach_enum(T, V, L, I) \
    if (bool continue__ = true) \
        if (int I = 1) if (I--)\
                for (commore::List<T>::iterator i__ = L.begin(); continue__ && i__; i__++, I++) \
                    if (bool b__ = true) if (__trueset(continue__, false))\
                            for (T& V = *i__;b__; b__ = false,continue__ = true)

#define cmr_const_foreach_enum(T, V, L, I) \
    if (bool continue__ = true) \
        if (int I = 1) if (I--)\
                for (commore::List<T>::const_iterator i__ = L.begin(); continue__ && i__; i__++, I++) \
                    if (bool b__ = true) if (__trueset(continue__, false))\
                            for (const T& V = *i__;b__; b__ = false,continue__ = true)


#define cmr_foreach_while(T, V, L, M) \
    if (bool continue__ = true) \
        for (commore::List<T>::iterator i__ = L.begin(); M && i__; i__++) \
            if (bool b__ = true) if (__trueset(continue__, false))  \
                    for (T& V = *i__;b__; b__ = false,continue__ = true)

#define cmr_const_foreach_while(T, V, L, M) \
    if (bool continue__ = true) \
        for (commore::List<T>::const_iterator i__ = L.begin(); M && i__; i__++) \
            if (bool b__ = true) if (__trueset(continue__, false))  \
                    for (const T& V = *i__;b__; b__ = false,continue__ = true)


#define cmr_remove_where(T, V, L, M) \
    if (bool keep__ = true) \
        if (bool continue__ = true) \
            for (commore::List<T>::iterator i__ = L.begin(); continue__ && i__; keep__ ? i__++ : i__.erase()) \
                if (bool b__ = true) if (__trueset(continue__, false)) \
                        for (T& V = *i__;b__; b__ = false,continue__ = true,(keep__ = !(M)))\
                            if (M)

#define cmr_move_where(T, V, S, D, M) \
    if (bool keep__ = true) \
        if (bool continue__ = true) \
            for (commore::List<T>::iterator i__ = S.begin(); continue__ && i__; keep__ ? i__++ : D.move_before(D.end(), i__++)) \
                if (bool b__ = true) if (__trueset(continue__, false)) \
                        for (T& V = *i__;b__; b__ = false,continue__ = true,(keep__ = !(M)))\
                            if (M)


#endif