Plist.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGPlist_HH_
#define _MGPlist_HH_

// Plist.h
//

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <algorithm>
#include <list>
#include "mg/MGCL.h"


//of MGPlist are transfered to MGPlist, and at the copy and assignment of MGPlist,
template <class T>
class MGPlist{
public:
    typedef typename std::list<T*>::iterator               iterator;
    typedef typename std::list<T*>::const_iterator         const_iterator;
    typedef typename std::list<T*>::reverse_iterator       reverse_iterator;
    typedef typename std::list<T*>::const_reverse_iterator const_reverse_iterator;
    typedef typename std::list<T*>::reference              reference;
    typedef typename std::list<T*>::const_reference        const_reference;
    typedef typename std::list<T*>::size_type              size_type;

    std::list<T*> m_list;

    MG_DLL_DECLR friend std::ostream& operator<< (std::ostream& out, const MGPlist<T>& lst);


    MGPlist(){;}

    MGPlist(const MGPlist<T>& rhs) : m_list(rhs.m_list){
        MGPlist<T>& rhsp = const_cast<MGPlist<T>&>(rhs);
        rhsp.m_list.clear();
    }

    explicit MGPlist(size_type n) : m_list(n, 0){;}

    template <class InputIter>
    MGPlist(InputIter first, InputIter last){
        insert(begin(), first, last);
    }

    ~MGPlist();


    MGPlist<T>& operator=(const MGPlist<T>& rhs);


    template <class InputIter>
    void assign(InputIter first, InputIter last){
        iterator cur= begin(), finish = end();
        for(; first != last && cur != finish; ++first, ++cur){
            delete *cur; *cur = *first;
        }
        (first == last) ? erase(cur, finish) : insert(finish, first, last);
    }

    const_reference back() const{
        return m_list.back();
    }
    reference back(){
        return m_list.back();
    }

    const_iterator begin() const{
        return m_list.begin();
    }
    iterator begin(){
        return m_list.begin();
    }

    void clear(){
        iterator first = begin(), last = end();
        for(; first != last; ++first)
            delete *first;
        m_list.clear();
    }

    bool empty() const{
        return m_list.empty();
    }

    const_iterator end() const{
        return m_list.end();
    }
    iterator end(){
        return m_list.end();
    }

    iterator erase(iterator x){
        delete *x;
        return m_list.erase(x);
    }
    iterator erase(iterator first, iterator last){
        for(; first != last; ++first) delete *first;
        return m_list.erase(first, last);
    }

    const_iterator find(T* obj) const{
        return std::find(begin(),end(),obj);
    }
    iterator find(T* obj){
        return std::find(begin(),end(),obj);
    }

    const_reference front() const{
        return m_list.front();
    }
    reference front(){
        return m_list.front();
    }

    iterator insert(iterator it, T* x){
        return m_list.insert(it,x);
    }

    template <class InputIter>
    void insert(iterator pos, InputIter first, InputIter last){
        for(; first != last; ++first) insert(pos, *first);
    }

    size_type max_size() const{
        return m_list.max_size();
    }

    void merge(MGPlist<T>& rhs){
        m_list.merge(rhs.m_list);
    }

    void pop_back(){
        delete m_list.back();
        m_list.pop_back();
    }

    void pop_front(){
        delete m_list.front();
        m_list.pop_front();
    }

    void push_back(T* x){
        m_list.push_back(x);
    }
    void push_back(MGPlist<T>& x){
        insert(end(), x.begin(), x.end());
        x.m_list.clear();
    }

    void push_front(T* x){
        m_list.push_front(x);
    }

    const_reverse_iterator rbegin() const{
        return m_list.rbegin();
    }
    reverse_iterator rbegin(){
        return m_list.rbegin();
    }

    const_reverse_iterator rend() const{
        return m_list.rend();
    }
    reverse_iterator rend(){
        return m_list.rend();
    }

    iterator release(iterator i){
        return m_list.erase(i);
    }

    void remove(T* x){
        m_list.remove(x);
    }

    template <class Pred>
    void remove_if(Pred pred){
        iterator first = begin(), last = end();
        while(first != last){
            iterator next = first;
            ++next;
            if(pred(*first)) m_list.erase(first);
            first = next;
        }
    }

    T* removeAt(iterator x){
        T* ret = *x;
        m_list.erase(x);
        return ret;
    }
    
    void reverse(){ m_list.reverse();}

    size_type size() const{ return m_list.size();}

    void sort(){ m_list.sort();}
    
    template<class Traits> 
    void sort(Traits _Comp){m_list.sort(_Comp);}

    void splice(iterator pos, MGPlist<T>& ls){
        m_list.splice(pos, ls.m_list);
    }
    void splice(iterator pos, MGPlist<T>& ls, iterator i){
        m_list.splice(pos, ls.m_list, i);
    }
    void splice(iterator pos, MGPlist<T>& ls, iterator first, iterator last){
        m_list.splice(pos, ls.m_list, first, last);
    }

    void swap(MGPlist<T>& x){
        m_list.swap(x.m_list);
    }

    void unique(){ m_list.unique();}
};


template <class T>
MGPlist<T>::~MGPlist(){
    iterator first = begin(), last = end();
    for(; first != last; ++first) delete *first;
}

template <class T>
MGPlist<T>& MGPlist<T>::operator=(const MGPlist<T>& rhs){
    if(this != &rhs){
        clear();
        m_list = rhs.m_list;
        MGPlist<T>& rhsp=const_cast<MGPlist<T>&>(rhs);
        rhsp.m_list.clear();
    }
    return *this;
}

template <class T>
std::ostream& operator<< (std::ostream& out, const MGPlist<T>& lst){
    out << "MGPlist<T>::";
    int n=lst.size();
    out<<"number of entries="<<n<<std::endl;
    MGPlist<T>::const_iterator itr; int i=0;
    for(itr=lst.begin(); itr!=lst.end(); itr++){
        out<<i++<<":"<<(*itr)<<std::endl;
        if(*itr) out << (**itr) << std::endl;
    }
    return out;
}
 // end of BASE group
#endif