alist.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef alist_h
#define alist_h

#include "error.h"

#include <cstddef>


namespace oofem {
template< class T > class AList
{
protected:
    int size;
    int allocatedSize;
    int sizeIncrement;
    T **values;

public:
    AList(int s = 0, int sizeIncrement = 0);
    ~AList();

    inline T *at(int i) const;
    void growTo(int newSize);
    void resize(int newSize);
    bool includes(int i) const;
    int giveSize() const { return size; }
    int isEmpty() const { return ( size == 0 ); }
    int isNotEmpty() const { return ( size != 0 ); }
    void printYourself() const;
    void put(int i, T *anObject);
    void clear(bool deleteObjectFlag = true);
    void remove(int i);
    T *unlink(int i);
};

template< class T >AList< T > :: AList(int s, int sizeIncrement)
// Constructor : creates a list of size s.
{
    int i;
    T **p;

    allocatedSize = size = s;
    if ( size ) {
        values = new T * [ size ];
        p      = values;
        i      = size;
        while ( i-- ) {
            * p++ = NULL;
        }
    } // initialize 'values'
    else {
        values = NULL;
    }

    this->sizeIncrement = sizeIncrement;
}


template< class T > AList< T > :: ~AList()
{
    this->clear(true);
}

template< class T > void
AList< T > :: clear(bool deleteObjectFlag)
{
    int i = size;

    if ( size ) {
        if ( deleteObjectFlag ) {
            while ( i-- ) {
                delete(values [ i ]);
            }
        }

        delete[]  values;
    }

    allocatedSize = size = 0;
    values = NULL;
}

template< class T > void
AList< T > :: growTo(int newSize)
// Expands the receiver from its current size to newSize, in order to accommodate new entries.
{
    int i;
    T **newValues, **p1, **p2;


    if ( newSize < size ) {
#ifdef DEBUG
        OOFEM_ERROR("new list size (%d) not larger than current size (%d)", newSize, size);
#endif
        // delete entities in indexes in the range (newSize, size)
        i = size;
        if ( size ) {
            while ( ( --i ) >= newSize ) {
                delete(values [ i ]);
                values [ i ] = NULL;
            }
        }
    } else if ( newSize > allocatedSize ) {
        this->allocatedSize = newSize + this->sizeIncrement;
        newValues = new T * [ this->allocatedSize ];
        p1        = values;
        p2        = newValues;
        for ( i = 0; i < size; i++ ) {
            * p2++ = * p1++;
        }

        for ( i = size; i < this->allocatedSize; i++ ) {
            * p2++ = NULL;
        }

        if ( values ) {
            delete[]  values;
        }

        values = newValues;
        this->allocatedSize = newSize + this->sizeIncrement;
    }

    size = newSize;
}

template< class T > void
AList< T > :: resize(int newSize)
// Expands the receiver from its current size to newSize, in order to accommodate new entries.
{
    int i;
    T **newValues, **p1, **p2;


    if ( newSize < size ) {
        // delete entities in indexes in the range (newSize, size)
        i = size;
        if ( size ) {
            while ( ( --i ) >= newSize ) {
                delete(values [ i ]);
                values [ i ] = NULL;
            }
        }
    } else if ( newSize > allocatedSize ) {
        this->allocatedSize = newSize + this->sizeIncrement;
        newValues = new T * [ this->allocatedSize ];
        p1        = values;
        p2        = newValues;
        for ( i = 0; i < size; i++ ) {
            * p2++ = * p1++;
        }

        for ( i = size; i < this->allocatedSize; i++ ) {
            * p2++ = NULL;
        }

        if ( values ) {
            //      delete [size] values ;
            delete[]  values;
        }

        values = newValues;
        this->allocatedSize = newSize + this->sizeIncrement;
    }

    size = newSize;
}

template< class T > T *
AList< T > :: at(int i) const
{
#ifdef DEBUG
    if ( i <= 0 ) {
        OOFEM_ERROR("Asking for negative or zero indices (%d)", i);
    }
#endif
    return values [ i - 1 ];
}

template< class T > bool
AList< T > :: includes(int i) const
// Returns True if the receiver has a non-null i-th entry, else returns
// False.
{
#ifdef DEBUG
    if ( i <= 0 ) {
        OOFEM_ERROR("Asking for negative or zero indices (%d)", i);
    }
#endif
    if ( i > size ) {
        return false;
    } else {
        return ( values [ i - 1 ] != NULL );
    }
}

template< class T > void
AList< T > :: printYourself() const
// Prints the receiver on screen.
{
    printf("List of components of size %d\n", size);
    for ( int i = 1; i <= size; i++ ) {
        printf("%d : %p\n", i, values [ i - 1 ]);
    }
}

template< class T > void AList< T > :: put(int i, T *anObject)
// Stores anObject at position i. Enlarge the receiver if too small.
{
#ifdef DEBUG
    if ( i <= 0 ) {
        OOFEM_ERROR("Trying to write to zero or negative indices (%d)", i);
    }
#endif
    if ( size < i ) {
        this->growTo(i);
    }

    // delete old value
    if ( values [ i - 1 ] ) {
        delete values [ i - 1 ];
    }

    values [ i - 1 ] = anObject;
}

template< class T > void AList< T > :: remove(int i)
{
#ifdef DEBUG
    if ( i < 0 ) {
        OOFEM_ERROR("Trying to remove at zero or negative indices (%d)", i);
    }
#endif

    if ( size < i ) {
        return;
    }

    if ( values [ i - 1 ] ) {
        delete values [ i - 1 ];
        values [ i - 1 ] = NULL;
    }
}


template< class T > T *AList< T > :: unlink(int i)
{
#ifdef DEBUG
    if ( i <= 0 ) {
        OOFEM_ERROR("Trying to unlink at zero or negative indices (%d)", i);
    }
#endif
    if ( size < i ) {
        return NULL;
    }

    T *answer = values [ i - 1 ];
    values [ i - 1 ] = NULL;
    return answer;
}
} // end namespace oofem
#endif // alist_h