array.h

Go to the documentation of this file.

#ifndef ARRAY_SIMBODY_H
#define ARRAY_SIMBODY_H



#include "base_data_package.h"

#include <iostream>
#include <string>
#include <cstdio>
#include <stdexcept>

static const int Array_CAPMIN = 1;

namespace SPH {
    template<class T> class Array
    {
    protected:
        int size_;
        int capacity_;
        int capacityIncrement_;
        T defaultValue_;
        T *array_;
    public:
        explicit Array(const T &aDefaultValue=T(),int aSize=0,int aCapacity=Array_CAPMIN)
        {
            setNull();
            defaultValue_ = aDefaultValue;
            int newCapacity;
            int min = aSize + 1;
            if(min < aCapacity) min = aCapacity;
            computeNewCapacity(min,newCapacity);
            ensureCapacity(newCapacity);
            size_ = aSize;
            if(size_<0) size_=0;
        }
        Array(const Array<T> &aArray)
        {
            setNull();
            *this = aArray;
        }
        virtual ~Array()
        {
            if(array_!=nullptr) { delete[] array_;  array_ = nullptr; }
        }
    private:
        void setNull()
        {
            size_ = 0;
            capacityIncrement_ = -1;
            capacity_ = 0;
            array_ = nullptr;
        }
    //=============================================================================
    // OPERATORS
    //=============================================================================
    public:
        bool arrayEquals(const Array<T> &aArray) const
        {
            return *this == aArray;
        }
        T& operator[](int aIndex) const
        {
            return(array_[aIndex]);
        }
        Array<T>& operator=(const Array<T> &aArray)
        {
            size_ = aArray.size_;
            capacity_ = aArray.capacity_;
            capacityIncrement_ = aArray.capacityIncrement_;
            defaultValue_ = aArray.defaultValue_;

            // ARRAY
            if(array_!=nullptr) delete[] array_;
            array_ = new T[capacity_];
            for(int i = 0;i < capacity_; i++) array_[i] = aArray.array_[i];

            return(*this);
        }
        bool operator==(const Array<T> &aArray) const
        {
            if(size_ != aArray.size_) return(false);

            int i;
            for(i=0; i<size_; i++) 
            {
                if( !(array_[i]==aArray.array_[i]) ) return(false);
            }

            return(true);
        }
        friend std::ostream& operator<<(std::ostream &aOut,const Array<T> &aArray)
        {
            int i;
            for(i=0; i<aArray.getSize(); i++)  {
                aOut << " ";
                aOut << aArray[i];
            }   

            return(aOut);
        }

        friend std::istream& operator>>(std::istream& in, Array<T>& out) 
        {    
            return in;
        }
        bool computeNewCapacity(int aMinCapacity,int &rNewCapacity)
        {
            rNewCapacity = capacity_;
            if(rNewCapacity < Array_CAPMIN) rNewCapacity = Array_CAPMIN;

            if(capacityIncrement_ == 0) {
                std::cout << "Array.computeNewCapacity: WARN- capacity is set";
                std::cout << " not to increase (i.e., capacityIncrement_==0).\n";
                return(false);
            }

            while(rNewCapacity < aMinCapacity) {
                if(capacityIncrement_ < 0) {
                    rNewCapacity = 2 * rNewCapacity;
                } else {
                    rNewCapacity = rNewCapacity + capacityIncrement_;
                }
            }

            return(true);
        }
        bool ensureCapacity(int aCapacity)
        {
            if(aCapacity < Array_CAPMIN) aCapacity = Array_CAPMIN;
            if(capacity_ >= aCapacity) return(true);

            int i;
            T *newArray = new T[aCapacity];
            if(newArray == nullptr) 
            {
                std::cout << "Array.ensureCapacity: ERR- failed to increase capacity.\n";
                return(false);
            }

            if(array_ != nullptr) {
                for(i =0; i < size_; i++) newArray[i] = array_[i];
                for(i = size_; i < aCapacity; i++) newArray[i] = defaultValue_;
                delete []array_;  
                array_ = nullptr;
            } else {
                for(i = 0; i < aCapacity; i++) newArray[i] = defaultValue_;
            }
    
            capacity_ = aCapacity;
            array_ = newArray;

            return(true);
        }

        void trim()
        {
            int newCapacity = size_ + 1;
            if(newCapacity >= capacity_) return;
            if(newCapacity < Array_CAPMIN) newCapacity = Array_CAPMIN;

            int i;
            T *newArray = new T[newCapacity];
            if(newArray==nullptr) {
                std::cout << "Array.trim: ERR- unable to allocate temporary array.\n";
                return;
            }

            for(i = 0; i < size_; i++) newArray[i] = array_[i];

            delete[] array_;

            array_ = newArray;

            capacity_ = newCapacity;
        }
        int getCapacity() const
        {

            return(capacity_);
        }
        void setCapacityIncrement(int aIncrement)
        {
            capacityIncrement_ = aIncrement;
        }

        int getCapacityIncrement() const
        {
            return(capacityIncrement_);
        }
        bool setSize(int aSize)
        {
            if(aSize == size_) return(true);
            if(aSize < 0) aSize = 0;
            bool success = true;
            if(aSize < size_) 
            {
                int i;
                for(i = (size_ - 1);i >= aSize; i--) array_[i] = defaultValue_;
                size_ = aSize;
            } else if(aSize <= capacity_) {
                size_ = aSize;
            } else {
                int newCapacity;
                success = computeNewCapacity(aSize+1, newCapacity);
                if(!success) return(false);
                success = ensureCapacity(newCapacity);
                if(success) size_ = aSize;
            }

            return(success);
        }
        int getSize() const
        {
            return(size_);
        }
        int size() const {return getSize();}

        int append(const T &aValue)
        {
            if((size_ + 1) >= capacity_) {
                int newCapacity;
                bool success;
                success = computeNewCapacity(size_ + 1, newCapacity);
                if(!success) return(size_);
                success = ensureCapacity(newCapacity);
                if(!success) return(size_);
            }

            array_[size_] = aValue;
            size_++;

            return(size_);
        }
        int append(const Array<T> &aArray)
        {
            int i,n = aArray.getSize();
            for(i = 0; i < n; i++) {
                append(aArray[i]);
            }

            return(size_);
        }

        int append(int aSize,const T *aArray)
        {
            if(aSize < 0) return(size_);
            if(aArray == nullptr) return(size_);

            int i;
            for(i = 0;i < aSize; i++) {
                append(aArray[i]);
            }

            return(size_);
        }
        int insert(int aIndex,const T &aValue)
        {
            if(aIndex<0) {
                std::cout << "Array.insert: ERR- aIndex was less than 0.\n";
                return(size_);
            }

            if(aIndex >= size_) {
                setSize(aIndex+1);
                array_[aIndex] = aValue;
                return(size_);
            }

            if((size_ + 1) >= capacity_) {
                int newCapacity;
                bool success;
                success = computeNewCapacity(size_ + 1,newCapacity);
                if(!success) return(size_);
                success = ensureCapacity(newCapacity);
                if(!success) return(size_);
            }

            int i;
            for(i = size_; i > aIndex; i--) {
                array_[i] = array_[i-1];
            }

            array_[aIndex] = aValue;
            size_++;

            return(size_);
        }
        int remove(int aIndex)
        {
            if(aIndex < 0) {
                std::cout << "Array.remove: ERR- aIndex was less than 0.\n";
                return(size_);
            }
            if(aIndex >= size_) {
                std::cout << "Array.remove: ERR- aIndex was greater than or equal the ";
                std::cout << "size of the array.\n";
                return(size_);
            }

            int i;
            size_--;
            for(i = aIndex; i < size_; i++) {
                array_[i] = array_[i+1];
            }
            array_[size_] = defaultValue_;

            return(size_);
        }
        void set(int aIndex,const T &aValue)
        {
            if(aIndex < 0) return;

            bool success = false;
            if((aIndex+2) >= capacity_) {
                int newCapacity;
                success = computeNewCapacity(aIndex+2, newCapacity);
                if(!success) return;
                success = ensureCapacity(newCapacity);
                if(!success) return;
            }
            array_[aIndex] = aValue;
            if(aIndex >= size_)  size_ = aIndex + 1;
        }
        T* get()
        {
            return(array_);
        }
        const T* get() const
        {
            return(array_);
        }
        const T& get(int aIndex) const
        {
            if((aIndex < 0) || (aIndex >= size_)) {
                std::stringstream msg;
                msg << "Array index out of bounds. " << ".";
                throw (msg.str(),__FILE__,__LINE__);
            }
            return(array_[aIndex]);
        }
        const T& getLast() const
        {
            if(size_ <= 0) {
                std::stringstream msg;
                msg << "Array is empty. " << ".";
                throw (msg.str(),__FILE__,__LINE__);
            }
            return(array_[size_ - 1]);
        }
        T& updLast() const
        {
            if(size_ <= 0) {
                std::stringstream msg;
                msg << "Array is empty. " << ".";
                throw (msg.str(),__FILE__,__LINE__);
            }
            return(array_[size_ - 1]);
        }
        int findIndex(const T &aValue) const
        {
            for(int i = 0; i < size_; i++) if(array_[i] == aValue) return i;
            return -1;
        }

        int rfindIndex(const T &aValue) const
        {
            for(int i=size_ - 1; i >= 0; i--) if(array_[i]==aValue) return i;
            return -1;
        }
    }; 
}
#endif //ARRAY_SIMBODY_H