CORE_ArrayList.h

Go to the documentation of this file.

#ifndef CORE_ArrayList_H
#define CORE_ArrayList_H


#include "CORE_Array.h"

template <class T>
class CORE_ArrayList : public CORE_Array<T> , public CORE_List {

    
private:
  
    
    // capacity factor: the multiplicator factor for reallocation for list operator
    // if 1 : no multiplication
    tFlag mCapacityFactor;
    tFlag mOrder;

    // CONSTRUCTORS
public:
    CORE_ArrayList():CORE_Array<T>() {
        mCapacityFactor=2;
        mOrder=CORE_List::NO_ORDER;
    }
    CORE_ArrayList(const CORE_Array<T>& c):CORE_Array<T>(c) {
        mCapacityFactor=c.getCapacityfactor();
        mOrder=CORE_List::NO_ORDER;
    }
    CORE_ArrayList(const tUIndex& n):CORE_Array<T>(n) {
        mCapacityFactor=2;
        mOrder=CORE_List::NO_ORDER;
    }
   
  

 
    // DESTRUCTORS
    virtual ~CORE_ArrayList() {
    }
  
 

    // -----------------------
    // shared pointer operator
    // ------------------------
public:
    void getSharedPointer(boost::shared_ptr<CORE_ArrayList<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<CORE_ArrayList<T> >(r);   
    };
    void getSharedPointer( boost::shared_ptr<const CORE_ArrayList<T> >& p) const{               
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const CORE_ArrayList<T> >(r);                             
    }; 
private:
    inline boost::shared_ptr<CORE_ArrayList<T> > getThis() {
        boost::shared_ptr<CORE_ArrayList<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const CORE_ArrayList<T> > getThis() const {                                       
        boost::shared_ptr<const CORE_ArrayList<T> > p;
        getSharedPointer(p);
        return p;       
    };

    // ----------------
    // New constructors
    // ----------------
public:
    static inline boost::shared_ptr<CORE_ArrayList<T> > New() {
        boost::shared_ptr<CORE_ArrayList<T> > p(new CORE_ArrayList<T>(),
                                                CORE_Object::Delete());
        p->setThis(p);
        return p;
    };
    static inline boost::shared_ptr<CORE_ArrayList<T> > New(const tUIndex& n) {
        boost::shared_ptr<CORE_ArrayList<T> > p(new CORE_ArrayList<T>(n),
                                                CORE_Object::Delete());
        p->setThis(p);
        return p;
    };  
    // ---------------------------
    // Accessor & basic operators
    // ---------------------------

    template<class Q>
    CORE_ArrayList<T>& operator=(const CORE_ArrayList<Q>& f) {
        copy(f);
        return (*this);
    };
    template<class Q>
    inline CORE_ArrayList<T>& operator=(const Q& f) {
        CORE_Array<T>::initArray(f);
        return (*this);
    };

    template<class Q>
    void copy(const CORE_Array<Q>& f) {
        CORE_Array<T>::copy(f);
        const CORE_ArrayList<Q>* lf=dynamic_cast<const CORE_ArrayList<Q>* >(&f);
        if (lf!=null) {
            setCapacityFactor(lf->getCapacityFactor());
            setOrder(lf->getOrder());
        }
    }
public:
   
 


    // SET & GET Methods
    // ==================
    inline void setCapacityFactor(const tFlag& n) {
        mCapacityFactor=n;
    };
    inline const tFlag& getCapacityFactor() const {return mCapacityFactor;};

    inline void setOrder(const tFlag& order) {
        mOrder=order;
    }
    inline const tFlag&  getOrder() const {
        return mOrder;
    }
    //LIST Manipulations
    //===================
    virtual void clear() {
        CORE_Array<T>::clear();
    }
    
    /* \brief add an element to the array
     * @param v: value to add
     */
    template<class Q>
    void push_back(const Q& v);

 
    void insertAtIndex(const tUIndex& i,const T& v);

    tUIndex insert(const T& v);
    
    
    tBoolean remove(const T& v);

    void removeAtIndex(const tUIndex& i);
    
    void contractToLastElements(const tUIndex& n);
  
    
    
    inline tBoolean exists(const T& obj) const {
        const T* values=CORE_Array<T>::getValues();
        const tUIndex& n=CORE_Array<T>::getSize();
        for (tUIndex i=0;i<n;i++) {
            if (*values==obj) {
                return true;
            }
            values++;
        }
        return false;
    }
    
    void reverse();

   
    
    void append(const CORE_ArrayList<T>& array);

public:
    // -----------------
    // SORTING Methods
    // -----------------
    
    inline void sort(const tFlag& order) {
        mOrder=order;
        sort(&(*this)[0],CORE_Array<T>::getSize(),order);
    };
    inline void sort() {
        //if no order is specified, order in increasing list by default
        if (mOrder==CORE_List::NO_ORDER) setOrder(CORE_List::LT);
        sort(mOrder);
    };
  
    static void sort(T* items,
                     const tUIndex& N,
                     const tFlag& order);

  
    static tBoolean search(const T* values, const tUIndex& n,const tFlag& order,
                           const T& value,
                           tUIndex& index);
    
    inline tBoolean search(const T& value,tUIndex& index) {
        return search(CORE_Array<T>::getValues(),
                      CORE_Array<T>::getSize(),
                      getOrder(),value,index);
        
    }
    



 
};

#include "CORE_ArrayList.hpp"

typedef CORE_ArrayList<double> CORE_DoubleArrayList;
typedef CORE_ArrayList<tChar> CORE_CharArrayList;
typedef CORE_ArrayList<tInt> CORE_IntArrayList;
typedef CORE_ArrayList<tBoolean> CORE_BooleanArrayList;
typedef CORE_ArrayList<tReal> CORE_RealArrayList;
typedef CORE_ArrayList<tComplex> CORE_ComplexArrayList;
typedef CORE_ArrayList<tDComplex> CORE_DoubleComplexArrayList;
typedef CORE_ArrayList<tFlag> CORE_FlagArrayList;
typedef CORE_ArrayList<tSInt> CORE_ShortArrayList;
typedef CORE_ArrayList<tSInt> CORE_SIntArrayList;
typedef CORE_ArrayList<tUSInt> CORE_USIntArrayList;
typedef CORE_ArrayList<tInteger> CORE_IntegerArrayList;
typedef CORE_ArrayList<tUInteger> CORE_UIntegerArrayList;
typedef CORE_ArrayList<tLInt> CORE_LongArrayList;
typedef CORE_ArrayList<tUIndex> CORE_UIndexArrayList;
typedef CORE_ArrayList<tIndex> CORE_IndexArrayList;


TYPEDEF_SPTR(CORE_DoubleArrayList);
TYPEDEF_SPTR(CORE_BooleanArrayList);
TYPEDEF_SPTR(CORE_CharArrayList);
TYPEDEF_SPTR(CORE_IntArrayList);
TYPEDEF_SPTR(CORE_RealArrayList);
TYPEDEF_SPTR(CORE_ComplexArrayList);
TYPEDEF_SPTR(CORE_FlagArrayList);
TYPEDEF_SPTR(CORE_UIntegerArrayList);
TYPEDEF_SPTR(CORE_IntegerArrayList);
TYPEDEF_SPTR(CORE_ShortArrayList);
TYPEDEF_SPTR(CORE_LongArrayList);
TYPEDEF_SPTR(CORE_UIndexArrayList);
TYPEDEF_SPTR(CORE_IndexArrayList);

TYPEDEF_SVPTR(CORE_DoubleArrayList)
TYPEDEF_SVPTR(CORE_BooleanArrayList);
TYPEDEF_SVPTR(CORE_CharArrayList);
TYPEDEF_SVPTR(CORE_IntArrayList);
TYPEDEF_SVPTR(CORE_RealArrayList);
TYPEDEF_SVPTR(CORE_ComplexArrayList);
TYPEDEF_SVPTR(CORE_FlagArrayList);
TYPEDEF_SVPTR(CORE_UIntegerArrayList);
TYPEDEF_SVPTR(CORE_IntegerArrayList);
TYPEDEF_SVPTR(CORE_ShortArrayList);
TYPEDEF_SVPTR(CORE_UIndexArrayList);
TYPEDEF_SVPTR(CORE_IndexArrayList);
#endif