list.h

Go to the documentation of this file.

#pragma once
 
#include "Common/Float.h"
 
namespace COMM {
 
 
    enum class ListMode {copy, local, link ,none};
 
 
    template <class Ttype>
    class List{
    protected:
        int num_;          
        int nmax_;         
        Ttype* data_;      
        Ttype** adr_;      
        ListMode mode_;    
 
        //flag
        bool modified_flag_;     
    public:
 
 
        List(): num_(0), nmax_(0), data_(NULL), adr_(NULL), mode_(ListMode::none), modified_flag_(false) {};
 
 
        void setMode(const ListMode _mode) {
            ASSERT(mode_==ListMode::none);
            mode_ = _mode;
        }
        
 
        void reserveMem(const int _nmax) {
            ASSERT(nmax_==0);
            ASSERT(_nmax>0);
            ASSERT(adr_==NULL);
            ASSERT(data_==NULL);
            ASSERT(mode_!=ListMode::none);
 
            switch(mode_) {
            case ListMode::copy: 
                data_=new Ttype[_nmax];
                adr_=new Ttype*[_nmax];
                nmax_ = _nmax;
                break;
            case ListMode::local:
                data_=new Ttype[_nmax];
                nmax_ = _nmax;
                break;
            case ListMode::link:
                break;
            case ListMode::none:
                break;
            }
        }
 
 
 
        void clear() {
            switch(mode_) {
            case ListMode::copy:
                ASSERT(data_!=NULL);
                ASSERT(adr_!=NULL);
                delete[] data_;
                delete[] adr_;
                num_ = 0;
                nmax_ =0;
                data_= NULL;
                adr_ = NULL;
                break;
            case ListMode::local:
                ASSERT(data_!=NULL);
                ASSERT(adr_==NULL);
                delete[] data_;
                num_ = 0;
                nmax_ =0;
                data_=NULL;
                break;
            case ListMode::link:
                ASSERT(adr_==NULL);
                num_ = 0;
                nmax_ = 0;
                data_=NULL;
                break;
            case ListMode::none:
                ASSERT(num_==0);
                ASSERT(nmax_==0);
                ASSERT(data_==NULL);
                ASSERT(adr_==NULL);
                break;
            }
            mode_ = ListMode::none;
            modified_flag_ = false;
        }
    
        /* Copy function will remove the local data and also copy the member data or the link
         */
        List& operator = (const List& _list) {
            clear();
            mode_ = _list.mode_;
            switch(mode_) {
            case ListMode::copy:
                reserveMem(_list.nmax_, mode_); 
                num_ = _list.num_; 
                for(int i=0; i<num_; i++) data_[i] = _list.data_[i];
                for(int i=0; i<num_; i++)  adr_[i] = _list.adr_[i];
                break;
            case ListMode::local:
                reserveMem(_list.nmax_, mode_);
                num_ = _list.num_; 
                for(int i=0; i<num_; i++) data_[i] = _list.data_[i];
                break;
            case ListMode::link:
                num_ = _list.num_; 
                nmax_ = _list.nmax_;
                data_ = _list.data_;
                break;
            case ListMode::none:
                break;
            }
            modified_flag_     = _list.modified_flag_;
            return *this;
        }
 
        ~List() {
            clear();
        }
 
 
        int getSize() const {
            return num_;
        }
 
        ListMode getMode() const {
            return mode_;
        }
    
 
        Ttype& getMember(const int _index) {
            ASSERT(_index<num_);
            ASSERT(_index>=0);
            return data_[_index];
        }
 
        Ttype* getDataAddress() const {
            return data_;
        }
 
        Ttype** getOriginAddressArray() const {
            return adr_;
        }
 
        Ttype& getLastMember() {
            return data_[num_-1];
        }
 
 
        Ttype& operator [](const int _index) const {
            ASSERT(_index<num_);
            ASSERT(_index>=0);
            return data_[_index];
        }
 
 
        Ttype* getMemberOriginAddress(const int _index) const{
            ASSERT(mode_==ListMode::copy);
            ASSERT(_index<num_);
            ASSERT(_index<nmax_);
            ASSERT(_index>=0);
            return adr_[_index];
        }
 
 
        int getSizeMax() const {
            return nmax_;
        }
    
 
        template <class T>
        void addMemberAndAddress(T &_member) {
            ASSERT(mode_==ListMode::copy);
            ASSERT(num_<nmax_);
            data_[num_] = _member;
            adr_[num_]  = (Ttype*)&_member;
            num_++;
            modified_flag_ = true;
        }
 
 
        template <class T>
        void addMember(const T &_member) {
            ASSERT(mode_==ListMode::local);
            ASSERT(num_<nmax_);
            data_[num_] = _member;
            num_++;
            modified_flag_ = true;
        }
 
 
        void increaseSizeNoInitialize(const int _n) {
            ASSERT(mode_==ListMode::local||mode_==ListMode::link);
            ASSERT(num_+_n<=nmax_);
            num_ += _n;
            modified_flag_ = true;
        }
 
 
        void decreaseSizeNoInitialize(const int _n) {
            ASSERT(mode_==ListMode::local||mode_==ListMode::link);
            ASSERT(num_-_n>=0);
            num_ -= _n;
            modified_flag_ = true;
        }
 
 
        void resizeNoInitialize(const int _n) {
            ASSERT(mode_==ListMode::local||mode_==ListMode::link);
            ASSERT(_n<=nmax_);
            num_ = _n;
            modified_flag_ = true;
        }
    
 
        void linkMemberArray(Ttype _member[], const int _n_member) {
            ASSERT(mode_==ListMode::link);
            ASSERT(nmax_==0);
            ASSERT(num_==0);
            ASSERT(data_==NULL);
            data_= _member;
            num_ = _n_member;
            nmax_= _n_member;
            modified_flag_ = true;
        }
 
 
        static void createRemoveTable(const int* _index, const int _n_index, const int _n_member, int* _remove_table) {
            ASSERT(_n_index>0);
            ASSERT(_n_member>=_n_index);
            
            // last member index 
            int ilast = _n_member-1;
            const int n_new = _n_member - _n_index; // new ptcl number
            // initial table
            for (int i=0; i<_n_member; i++) _remove_table[i] = -1;
 
            for (int i=0; i<_n_index; i++) {
                int k=_index[i];
                
                int idel = k;
                
                // set ilast >= idel for safety.
                ilast = std::max(ilast, idel);
            
                // check whether position is already moved, if so, check the moved new position and set current to delete
                if(_remove_table[k]>=0) {
                    idel=_remove_table[k];
                    _remove_table[k]=_n_member;
                }
 
                ASSERT(k<_n_member);
                ASSERT(idel<_n_member);
                
                // check the last avaiable member that can be moved to idel
                // If the ilast is already moved, check whether the new moved position _remove_table[ilast] is before the current idel.
                // If _remove_table[ilast] is after the current idel, update the _remove_table[ilast] to idel and set _remove_table[ilast] as new idel to check, until _remove_table[ilast]=-1 or idel >= ilast
                while (idel>=0) {
                    int itrlast = -1;
                    //cond: last is moved && ( moved pos before new n_ptcl || last is del ) &&  ilast > idel 
                    while(_remove_table[ilast]>=0 && (_remove_table[ilast]<n_new || _remove_table[ilast]==_n_member) && ilast>idel) ilast--;
 
                    // if ilast is not yet moved or (new pos of ilast > idel and ilast is not del, move ilast to idel)
                    if(_remove_table[ilast]<0||(idel<_remove_table[ilast]&&_remove_table[ilast]<_n_member)) {
                        itrlast=_remove_table[ilast];
                        _remove_table[ilast]=idel;
                    }
                    // idel is already at last, remove it
                    _remove_table[idel]=_n_member; 
                    idel = itrlast;
                }
            }
        }
    
 
        void removeMember(const int _index, const bool _shift_last_only_flag) {
            ASSERT(_index>=0);
            ASSERT(_index<num_);
 
            int ilast = num_-1;
            if (_index<ilast) {
                if (_shift_last_only_flag) {
                    data_[_index] = data_[ilast];
                    if(mode_==ListMode::copy) adr_[_index] = adr_[ilast];
                }
                else {
                    if(mode_==ListMode::copy) {
                        for (int j=_index; j<ilast; j++) {
                            data_[j] = data_[j+1];
                            adr_[j]  = adr_[j+1];
                        }
                    }
                    else {
                        for (int j=_index; j<ilast; j++) data_[j] = data_[j+1];
                    }
                }
            }
            num_--;
            modified_flag_ = true;
        }
 
 
 
        void removeMemberTable(const int* remove_table) {
            const int num_org = num_;
            if (mode_==ListMode::copy) {
                for (int i=0; i<num_org; i++) {
                    ASSERT(remove_table[i]<=num_org);
                    // no change case
                    if(remove_table[i]<0) continue;
                    // move case
                    else if(remove_table[i]<num_org) {
                        const int inew = remove_table[i];
                        data_[inew] = data_[i];
                        adr_[inew] = adr_[i];
                    }
                    // remove count
                    else num_--;
                }
            }
            else {
                for (int i=0; i<num_org; i++) {
                    ASSERT(remove_table[i]<=num_org);
                    // no change case
                    if(remove_table[i]<0) continue;
                    // move case
                    else if(remove_table[i]<num_org) {
                        const int inew = remove_table[i];
                        data_[inew] = data_[i];
                    }
                    // remove count
                    else num_--;
                }
            }
            modified_flag_ = true;
        }
 
 
        void removeMemberList(const int* _index, const int _n_index) {
            ASSERT(_n_index<=num_);
            const int num_org = num_;
            int remove_table[num_];
            createRemoveTable(_index, _n_index, num_, remove_table);
            removeMemberTable(remove_table);
            ASSERT(num_+_n_index==num_org);
        }
 
 
        template <class T>
        void writeBackMemberAll() {
            ASSERT(mode_==ListMode::copy);
            ASSERT(nmax_>0);
            for (int i=0; i<num_; i++) {
                if(adr_[i]!=NULL) *(T*)adr_[i] = data_[i];
            }
        }
 
 
        template <class T>
        void writeBackMemberList(const int* _index, const int _n) {
            ASSERT(mode_==ListMode::copy);
            ASSERT(nmax_>0);
            for (int i=0; i<_n; i++) {
                int k=_index[i];
                if(adr_[k]!=NULL) *(T*)adr_[k] = data_[k];
            }
        }
 
        bool isModified() const {
            return modified_flag_;
        }
 
        void setModifiedFalse() {
            modified_flag_ = false;
        }
 
    };
}