pzmanvector.h

Go to the documentation of this file.

#ifndef PZMANVECTOR_H
#define PZMANVECTOR_H

#include "pzvec.h"
#include "pzerror.h"

const int DEFAULTVEC_ALLOC = 10;

template < class T, int NumExtAlloc = DEFAULTVEC_ALLOC >
class TPZManVector : public TPZVec< T > {
public:
    TPZManVector(const int64_t size = 0);

    TPZManVector(const int64_t size, const T& copy);

    TPZManVector(const TPZManVector< T, NumExtAlloc >& copy);

    TPZManVector(const TPZVec<T> & copy);

                TPZManVector(const std::initializer_list<T>& list);

    TPZManVector< T, NumExtAlloc >& operator=(const TPZManVector< T, NumExtAlloc >& copy);

                TPZManVector< T, NumExtAlloc >& operator=(const std::initializer_list<T>& list);

    virtual ~TPZManVector();

    inline int NAlloc() const {
        return fNAlloc;
    }

    void Expand(const int64_t newsize);

    void Shrink();

    virtual void Resize(const int64_t newsize, const T& object);

    virtual void Resize(const int64_t newsize);

private:

    int64_t ExpandSize(const int64_t proposed) const;

    int fNAlloc;

    T fExtAlloc[ NumExtAlloc ];
};

//--| IMPLEMENTATION |----------------------------------------------------------

template< class T, int NumExtAlloc >
TPZManVector< T, NumExtAlloc >::TPZManVector(const int64_t size) :
TPZVec<T>(0) // There is always some static allocation.
{
    /* If the size requested fits inside the size already provided
     * statically, provides access to that space, by setting some
     * TPZVec data.
     */
    if (size <= NumExtAlloc) {
        // Needed to make TPZVec::operator[] work properly.
        this->fStore = fExtAlloc;
        this->fNElements = size;
        // No memory was allocated by the constructor.
        fNAlloc = 0;
    } else // The size requested is bigger than the size already provided.
    {
        // Executes the allocation that would be done by TPZVec<T>(size).
        this->fStore = new T[ size ];
        this->fNElements = size;
        fNAlloc = size;
    }
}

template< class T, int NumExtAlloc >
TPZManVector< T, NumExtAlloc >::TPZManVector(const int64_t size, const T& copy) :
TPZVec<T>(0)
//fNExtAlloc( NumExtAlloc ) // There is always some static allocation.
{
    /* If the size requested fits inside the size already provided
     * statically, provides access to that space, by setting some
     * TPZVec data.
     */
    if (size <= NumExtAlloc) {
        // Needed to make TPZVec::operator[] work properly.
        this->fStore = fExtAlloc;
        this->fNElements = size;
        // No memory was allocated by the constructor.
        fNAlloc = 0;
    } else // The size requested is bigger than the size already provided.
    {
        // Executes the allocation that would be done by TPZVec<T>(size).
        this->fStore = new T[ size ];
        this->fNElements = size;
        fNAlloc = size;
    }

    for (int64_t i = 0; i < size; i++) {
        this->fStore[i] = copy;
    }
}

template< class T, int NumExtAlloc>
inline TPZManVector< T, NumExtAlloc >::TPZManVector(const TPZManVector< T, NumExtAlloc >& copy) {
    const int64_t size = copy.NElements();

    /* If the size requested fits inside the size already provided
     * statically, provides access to that space, by setting some
     * TPZVec data.
     */
    if (size <= (int64_t) (sizeof (fExtAlloc) / sizeof (T))) {
        // Needed to make TPZVec::operator[] work properly.
        this->fStore = fExtAlloc;
        this->fNElements = size;
        // No memory was allocated by the constructor.
        fNAlloc = 0;
    } else // The size requested is bigger than the size already provided.
    {
        // Executes the allocation that would be done by TPZVec<T>(size).
        this->fStore = new T[ size ];
        this->fNElements = size;
        fNAlloc = size;
    }

    for (int64_t i = 0; i < size; i++) {
        this->fStore[i] = copy.fStore[i];
    }
}

template< class T, int NumExtAlloc>
inline TPZManVector< T, NumExtAlloc >::TPZManVector(
        const TPZVec<T> & copy) {
    const int64_t size = copy.NElements();

    /* If the size requested fits inside the size already provided
     * statically, provides access to that space, by setting some
     * TPZVec data.
     */
    if (size <= (int64_t) (sizeof (fExtAlloc) / sizeof (T))) {
        // Needed to make TPZVec::operator[] work properly.
        this->fStore = fExtAlloc;
        this->fNElements = size;
        // No memory was allocated by the constructor.
        fNAlloc = 0;
    } else // The size requested is bigger than the size already provided.
    {
        // Executes the allocation that would be done by TPZVec<T>(size).
        this->fStore = new T[ size ];
        this->fNElements = size;
        fNAlloc = size;
    }

    for (int64_t i = 0; i < size; i++) {
        this->fStore[i] = copy[i];
    }
}

template< class T, int NumExtAlloc>
inline TPZManVector< T, NumExtAlloc >::TPZManVector(const std::initializer_list<T>& list)
{
                int size = list.size();
                std::cout << "init pzmanvec" << std::endl;
                if (size <= (int64_t)(sizeof(fExtAlloc) / sizeof(T))) {
                                // Needed to make TPZVec::operator[] work properly.
                                this->fStore = fExtAlloc;
                                this->fNElements = size;
                                // No memory was allocated by the constructor.
                                fNAlloc = 0;
                }
                else // The size requested is bigger than the size already provided.
                {
                                // Executes the allocation that would be done by TPZVec<T>(size).
                                this->fStore = new T[size];
                                this->fNElements = size;
                                fNAlloc = size;
                }

                auto it_end = list.end();
                T* aux = this->fStore;
                for (auto it = list.begin(); it != it_end; it++, aux++)
                                *aux = *it;
}


template< class T, int NumExtAlloc >
TPZManVector< T, NumExtAlloc >& TPZManVector< T, NumExtAlloc >::operator=(const TPZManVector< T, NumExtAlloc >& copy) {
    // Checking auto assignment.
    if (this == &copy) {
        return *this;
    }

    const int64_t nel = copy.NElements();

    if (nel > fNAlloc && this->fStore && this->fStore != fExtAlloc) {
        delete [] this->fStore;
        this->fStore = 0;
        fNAlloc = 0;
    }

    if (nel <= NumExtAlloc) {
        if (this->fStore != fExtAlloc) {
            delete []this->fStore;
        }
        this->fNAlloc = 0;
        this->fStore = fExtAlloc;
        this->fNElements = nel;
    } else if (fNAlloc >= nel) {
        this->fNElements = nel;
    } else {
        this->fStore = new T[ nel ];
        fNAlloc = nel;
        this->fNElements = nel;
    }

    for (int64_t i = 0; i < nel; i++) {
        this->fStore[i] = copy.fStore[i];
    }

    return *this;
}

template< class T, int NumExtAlloc >
TPZManVector< T, NumExtAlloc >& TPZManVector< T, NumExtAlloc >::operator=(const std::initializer_list<T>& list) {
                size_t size = list.size();

                if (size > this->fNAlloc && this->fStore && this->fStore != this->fExtAlloc) {
                                delete[] this->fStore;
                                this->fStore = 0;
                                this->fNAlloc = 0;
                }

                if (size <= NumExtAlloc) {
                                if (this->fStore != fExtAlloc) {
                                                delete[]this->fStore;
                                }
                                this->fNAlloc = 0;
                                this->fStore = fExtAlloc;
                                this->fNElements = size;
                }
                else if (fNAlloc >= size) {
                                this->fNElements = size;
                }
                else {
                                this->fStore = new T[size];
                                fNAlloc = size;
                                this->fNElements = size;
                }

                auto it_end = list.end();
                T* aux = this->fStore;
                for (auto it = list.begin(); it != it_end; it++, aux++)
                                *aux = *it;

                return *this;
}

template< class T, int NumExtAlloc >
TPZManVector< T, NumExtAlloc >::~TPZManVector() {
    if (this->fStore == fExtAlloc) {
        this->fStore = 0;
    }

    //   fNExtAlloc = 0;
    fNAlloc = 0;
}

template< class T, int NumExtAlloc >
void TPZManVector< T, NumExtAlloc >::Expand(const int64_t newsize) {
    // If newsize is negative then return.
    if (newsize <= fNAlloc || newsize <= NumExtAlloc) {
        return;
    } else {// the size is larger than the allocated memory
        T* newstore = new T[ newsize ];

        for (int64_t i = 0L; i < this->fNElements; i++) {
            newstore[i] = this->fStore[i];
        }

        if (this->fStore != fExtAlloc) {
            delete [] this->fStore;
        }

        this->fStore = newstore;
        fNAlloc = newsize;
    }
}

template< class T, int NumExtAlloc >
void TPZManVector< T, NumExtAlloc >::Shrink() {
    // Philippe : Porque NumExtAlloc <= fNAlloc????
    //    if(this->fNElements <= NumExtAlloc && NumExtAlloc <= fNAlloc) {
    if (this->fNElements <= NumExtAlloc) {
        if (this->fStore != fExtAlloc) {
            for (int64_t i = 0; i < this->fNElements; i++)
                fExtAlloc[i] = this->fStore[i];

            if (this->fStore)
                delete [] this->fStore;

            this->fStore = fExtAlloc;
            fNAlloc = NumExtAlloc;
        }
    } else if (fNAlloc != this->fNElements) { // then  fExtAlloc != this->fStore  because  NumExtAlloc != fNAlloc
        // Philippe : Memoria alocada externamente nao pode ser deletada
        //          if(fExtAlloc) delete[] fExtAlloc;
        T *newstore = 0;

        if (this->fNElements)
            newstore = new T[this->fNElements];

        for (int64_t i = 0; i < this->fNElements; i++)
            newstore[i] = this->fStore[i];

        if (this->fStore)
            delete[]this->fStore;

        this->fStore = newstore;
        fNAlloc = this->fNElements;

        // Philippe Isto eh um absurdo
        //          fExtAlloc = this->fStore;
        //          NumExtAlloc = fNAlloc;
    }
}

template< class T, int NumExtAlloc >
void TPZManVector< T, NumExtAlloc >::Resize(const int64_t newsize, const T& object) {
#ifndef NODEBUG
    if (newsize < 0) {
        PZError << "TManVec::Resize. Bad parameter newsize." << std::endl;
        PZError.flush();
        return;
    }
    if (newsize == this->fNElements)
        return;
#endif

    if (newsize <= fNAlloc) {
        for (int64_t i = this->fNElements; i < newsize; i++)
            this->fStore[i] = object;

        this->fNElements = newsize;
    } else if (newsize <= NumExtAlloc) { // that is, fExtAlloc != this->fStore. Moreover : this->fNElements <= fNAlloc
        // <= NumExtAlloc

        int64_t i;

        for (i = 0L; i < this->fNElements; i++) {
            fExtAlloc[i] = this->fStore[i];
        }

        for (; i < newsize; i++)
            fExtAlloc[i] = object;

        if (this->fStore != fExtAlloc) delete [] this->fStore;

        this->fStore = fExtAlloc;
        this->fNElements = newsize;
        fNAlloc = NumExtAlloc;
    } else { // the size is larger than the allocated memory, then this->fNElements
        // is always lower than newsize because fNElemets <=fNAllocs
        int64_t i, realsize = ExpandSize(newsize);

        T* newstore = new T[realsize];

        for (i = 0L; i < this->fNElements; i++) {
            newstore[i] = this->fStore[i];
        }

        for (; i < newsize; i++)
            newstore[i] = object;

        if (this->fStore != fExtAlloc)
            delete[]this->fStore;

        this->fStore = newstore;
        this->fNElements = newsize;
        fNAlloc = realsize;
    }
}

template< class T, int NumExtAlloc >
void TPZManVector< T, NumExtAlloc >::Resize(const int64_t newsize) {
#ifndef NODEBUG
    if (newsize < 0) {
        PZError << "TManVec::Resize. Bad parameter newsize." << std::endl;
        PZError.flush();
        return;
    }
#endif

    if (newsize == this->fNElements)
        return;

    if (newsize <= fNAlloc) {
        this->fNElements = newsize;
    } else if (newsize <= NumExtAlloc) { // that is, fExtAlloc != this->fStore
        if (this->fStore != fExtAlloc) {
            for (int64_t i = 0L; i < this->fNElements; i++) {
                fExtAlloc[i] = this->fStore[i];
            }
            delete [] this->fStore;
            this->fStore = fExtAlloc;
        }

        this->fNElements = newsize;
        fNAlloc = NumExtAlloc;
    } else { // the size is larger than the allocated memory, then this->fNElements
        // is always lower than newsize because fNElemets <=fNAllocs

        int64_t realsize = ExpandSize(newsize);
        T *newstore = new T[realsize];

        for (int64_t i = 0L; i < this->fNElements; i++) {
            newstore[i] = this->fStore[i];
        }

        if (this->fStore != fExtAlloc)
            delete [] this->fStore;

        this->fStore = newstore;
        this->fNElements = newsize;
        fNAlloc = realsize;
    }
}

template< class T, int NumExtAlloc >
int64_t TPZManVector < T, NumExtAlloc >::ExpandSize(const int64_t proposed) const {
    return ( proposed > fNAlloc * 1.2 ? proposed :
            static_cast<int64_t> (fNAlloc * 1.2));
}

#endif