Pvector.h

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

#if _MSC_VER > 1000
#pragma once
#endif 

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

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

    template <class T>
    MG_DLL_DECLR friend std::ostream& operator<< (std::ostream& out, const MGPvector<T>& vector);


    MGPvector(){;}

    explicit MGPvector(size_type len) : m_vector(len, 0){;}

    MGPvector(T* ptr) : m_vector(1, ptr){;}

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

    MGPvector(const std::vector<const T*>& rhs)
    :m_vector(rhs.size()){
        int n=rhs.size();
        for(int i=0; i<n; i++){
            m_vector[i]=new T(*(rhs[i]));
        }       
    }

    template <class InputIter>
    MGPvector(InputIter first, InputIter last){
        insert(end(), first, last);
    }


    ~MGPvector();


    const_reference operator[](size_type pos) const{
        return m_vector[pos];
    }
    reference operator[](size_type pos){
        return m_vector[pos];
    }

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


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

    void assign(size_type pos, T* ptr){
        delete m_vector[pos];
        m_vector[pos]=ptr;
    }

    const_reference at(size_type n) const{
        return m_vector.at(n);
    }
    reference at(size_type n){
        return m_vector.at(n);
    }

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

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

    size_type capacity() const{
        return m_vector.capacity();
    }

    void clear(){
        for(iterator i = begin(); i != end(); ++i)
            delete *i;
        m_vector.clear();
    }

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

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

    iterator erase(iterator x){
        delete *x;
        return m_vector.erase(x);
    }

    iterator erase(size_type i){
        iterator del = m_vector.begin() + i;
        delete *del;
        return m_vector.erase(del);
    }

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

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

    const_reference get(size_type i) const{
        return this->operator[](i);
    }
    reference get(size_type i){
        return this->operator[](i);
    }

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

    bool is_null(size_type i)const{
        return m_vector[i]==0;
    }

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

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

    void push_back(T* x){
        m_vector.push_back(x);
    }

    void push_back(MGPvector<T>& dst){
        m_vector.insert(m_vector.end(), dst.m_vector.begin(), dst.m_vector.end());
        dst.m_vector.clear();
    }

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

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

    T* release(size_type i){
        T* ret = m_vector[i];
        m_vector[i] = 0;
        return ret;
    }
    void release_all(){
        m_vector.assign(size(), static_cast<T*>(0));
    }

    T* removeAt(iterator i){
        T* ret = *i;
        m_vector.erase(i);
        return ret;
    }
    T* removeAt(size_type i){
        T* ret = m_vector[i];
        iterator del = m_vector.begin() + i;    
        m_vector.erase(del);
        return ret;
    }

    void reverse_sequence(){
        size_type i,n=size();
        size_type nhalf=n/2;
        for(i=0; i<nhalf; i++){
            size_type nmim1=n-i-1;
            T* pointer=m_vector[nmim1];
            m_vector[nmim1]=m_vector[i];
            m_vector[i]=pointer;
        }
    }

    void reserve(size_type n){
        m_vector.reserve(n);
    }

    void reset(size_type i, T* ptr = 0){
        delete m_vector[i];
        m_vector[i] = ptr;
    }

    void resize(size_type n);

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

    void swap(MGPvector<T>& x){
        m_vector.swap(x.m_vector);
    }
};


template <class T>
MGPvector<T>::~MGPvector(){
    for(iterator i = begin(); i != end(); ++i) delete *i;
}

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

template <class T>
void MGPvector<T>::resize(size_type n){
    size_type oldn=m_vector.size();
    if(oldn<n) m_vector.resize(n,0);
    else if(oldn>n){
        for(size_type i=n; i<oldn; i++) delete m_vector[i];
        m_vector.resize(n);
    }
}

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