extarray.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// An extendible array.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: June 15, 2012.


#ifndef _CHAINCON_EXTARRAY_H_
#define _CHAINCON_EXTARRAY_H_


// include selected header files from the CHomP library
#include "chomp/system/config.h"


// --------------------------------------------------
// -------------- an extendible array ---------------
// --------------------------------------------------

/// A simple extendible array that extends automatically when needed.
template <class ElemT>
class extarray
{
public:
        /// Default constructor.
        extarray ();

        /// Destructor.
        ~extarray ();

        /// Copy constructor.
        extarray (const extarray<ElemT> &other);

        /// Assignment operator.
        extarray<ElemT> &operator = (const extarray<ElemT> &other);

        /// Accesses a given element, and extends the array if necessary.
        ElemT &operator [] (int_t n);

        /// Accesses a given element without modifying the array.
        const ElemT &operator [] (int_t n) const;

        /// Swaps contents with another extensible array.
        void swap (extarray<ElemT> &other);

private:
        /// The length of the allocated array.
        int_t len;

        /// The array of elements.
        ElemT *arr;

}; /* class extarray */

// --------------------------------------------------

template <class ElemT>
inline extarray<ElemT>::extarray ():
        len (0), arr (0)
{
        return;
} /* extarray::extarray */

template <class ElemT>
inline extarray<ElemT>::~extarray ()
{
        if (arr)
                delete [] arr;
        return;
} /* extarray::~extarray */

template <class ElemT>
inline extarray<ElemT>::extarray (const extarray<ElemT> &other):
        len (other. len), arr (other. len ? new ElemT [other. len] : 0)
{
        for (int_t i = 0; i < len; ++ i)
                arr [i] = other. arr [i];
        return;
} /* extarray::extarray */

template <class ElemT>
inline extarray<ElemT> &extarray<ElemT>::operator =
        (const extarray<ElemT> &other)
{
        if (arr)
                delete [] arr;
        len = other. len;
        if (len)
        {
                arr = new ElemT [len];
                for (int_t i = 0; i < len; ++ i)
                        arr [i] = other. arr [i];
        }
        else
        {
                arr = 0;
        }
        return *this;
} /* extarray::operator = */

template <class ElemT>
inline ElemT &extarray<ElemT>::operator [] (int_t n)
{
        if (n < 0)
                throw "Negative offset requested for an extensible array.";
        if (!len)
        {
                len = n + 1;
                arr = new ElemT [len];
        }
        else if (len <= n)
        {
                int_t lenNew = len << 1;
                if (lenNew <= n)
                        lenNew = n + 1;
                ElemT *arrNew = new ElemT [lenNew];
                for (int_t i = 0; i < len; ++ i)
                        arrNew [i] = arr [i];
                delete [] arr;
                arr = arrNew;
                len = lenNew;
        }
        return arr [n];
} /* extarray::operator [] */

template <class ElemT>
inline const ElemT &extarray<ElemT>::operator [] (int_t n) const
{
        if (n < 0)
                throw "Negative offset while reading an extensible array.";
        if (n >= len)
                throw "Offset too large while reading an extensible array.";
        return arr [n];
} /* extarray::operator [] */

template <class ElemT>
inline void extarray<ElemT>::swap (extarray<ElemT> &other)
{
        int_t lenTemp = len;
        len = other. len;
        other. len = lenTemp;
        ElemT *arrTemp = arr;
        arr = other. arr;
        other. arr = arrTemp;
        return;
} /* extarray::swap */


#endif // _CHAINCON_EXTARRAY_H_