array.hxx

Go to the documentation of this file.

/*
 *   xyzzy
 *   Copyright (C) 2007    Karl W. Pfalzer
 *
 *   This program 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 2
 *   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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the
 *   Free Software Foundation, Inc.
 *   51 Franklin Street, Fifth Floor
 *   Boston, MA  02110-1301, USA.
 */

#if !defined(_xyzzy_array_hxx_)
#    define  _xyzzy_array_hxx_

#include "xyzzy/exception.hxx"
#include "xyzzy/refcnt.hxx"

namespace xyzzy
{
    class TArray
    {
    public:
        typedef signed long len_t;

        class IndexOutOfBoundsException : public TException
        {
        public:
            explicit IndexOutOfBoundsException(len_t max, len_t ix);

        private:
            len_t   m_max, m_ix;
        };

        len_t length() const
        {
            return m_len;
        }

    protected:
        explicit TArray();

        explicit TArray(len_t len);

        len_t checkIx(len_t ix) const throw(IndexOutOfBoundsException);

        len_t   m_len;
    };

    template<class T>
    class PTArray : public TArray
    {
    public:
        explicit PTArray()
        :   TArray(0), mp_ar(0)
        {}

        explicit PTArray(len_t len)
        :   mp_ar(0)
        {
            resize(len);
        }

        PTArray(const PTArray &r)
        :   mp_ar(0)
        {
            resize(r.length());
            copy(r);
        }
        
        explicit PTArray(const T* const p, const T stopAt)
        :   mp_ar(0)
        {
            int n = 0;
            for (; stopAt != p[n]; n++)
                ;
            resize(n);
            for (n = 0; n < length(); n++)
                this->operator[](n) = p[n];
        }

        PTArray& operator=(const PTArray &r)
        {
            resize(r.length());
            copy(r);
            return *this;
        }

        void resize(len_t len)
        {
            delete [] mp_ar;
            m_len = len;
            mp_ar = new T[m_len];
        }

        T& operator[](len_t ix)
        {
            return mp_ar[checkIx(ix)];
        }

        const T& operator[](len_t ix) const
        {
            return mp_ar[checkIx(ix)];
        }

        ~PTArray()
        {
            delete [] mp_ar;
        }

        static void copy(const PTArray &from, PTArray &to)
        {
            invariant(from.length() == to.length());
            for (int i = 0; i < from.length(); i++)
            {
                to[i] = from[i];
            }
        }

    private:
        T       *mp_ar;

        void copy(const PTArray &from)
        {
            copy(from, *this);
        }
    };

    template<class T>
    class PTRcArray
    {
    public:
        typedef TArray::len_t len_t;

        explicit PTRcArray()
        :   m_ar(0)
        {}

        PTRcArray(PTArray<T> *p)
        :   m_ar(p)
        {}

        PTRcArray(const PTRcArray &r)
        :   m_ar(r.m_ar)
        {}

        const PTRcArray& operator=(const PTRcArray &r)
        {
            if (this != &r)
            {
                m_ar = r.m_ar;
            }
            return *this;
        }

        len_t length() const
        {
            return m_ar->length();
        }

        T& operator[](len_t ix)
        {
            return m_ar->operator[](ix);
        }

        const T& operator[](len_t ix) const
        {
            return m_ar->operator[](ix);
        }

        bool isNull() const
        {
            return m_ar.isNull();
        }

    private:
        PTRcPtr<PTArray<T> >    m_ar;
    };
};

#endif  //_xyzzy_array_hxx_

---