arrays.h

/* ***** BEGIN LICENSE BLOCK *****
*
* $Id: arrays.h,v 1.3 2005/01/30 05:11:40 gabest Exp $ $Name:  $
*
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is BBC Research and Development code.
*
* The Initial Developer of the Original Code is the British Broadcasting
* Corporation.
* Portions created by the Initial Developer are Copyright (C) 2004.
* All Rights Reserved.
*
* Contributor(s): Thomas Davies (Original Author), Peter Meerwald ([email protected])
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
* Public License Version 2.1 (the "LGPL"), in which case the provisions of
* the GPL or the LGPL are applicable instead of those above. If you wish to
* allow use of your version of this file only under the terms of the either
* the GPL or LGPL and not to allow others to use your version of this file
* under the MPL, indicate your decision by deleting the provisions above
* and replace them with the notice and other provisions required by the GPL
* or LGPL. If you do not delete the provisions above, a recipient may use
* your version of this file under the terms of any one of the MPL, the GPL
* or the LGPL.
* ***** END LICENSE BLOCK ***** */

#ifndef _ARRAYS_H_
#define _ARRAYS_H_

//basic array types used for pictures etc

#include <memory>
#include <cstddef>
#include <stdexcept>
#include <iostream>
#include <algorithm>

namespace dirac
{
    typedef short ValueType;
    typedef int CalcValueType;


    class Range
    {
    public:

        Range(int s, int e): m_fst(s), m_lst(e){}

        const int First() const {return m_fst;}

        const int Last() const {return m_lst;}

    private:
        int m_fst ,m_lst;
    };

    //One-Dimensional Array type//


    template <class T> class OneDArray
    {
    public:

        OneDArray();


        OneDArray(const int len);


        OneDArray(const Range& r);


        ~OneDArray()
        {
            FreePtr();
        }


        OneDArray(const OneDArray<T>& cpy);


        OneDArray<T>& operator=(const OneDArray<T>& rhs);    

        void Resize(int l);

        T& operator[](const int pos){return m_ptr[pos-m_first];}

        const T& operator[](const int pos) const {return m_ptr[pos-m_first];}

        int Length() const {return m_length;}

        int First() const {return m_first;}

        int Last() const {return m_last;}

    private:
        void Init(const int len);

        void Init(const Range& r);

        void FreePtr();    

        int m_first, m_last;
        int m_length;
        T* m_ptr;
    };

    //public member functions//

    template <class T>
    OneDArray<T>::OneDArray()
    {
        Init(0);
    }

    template <class T>
    OneDArray<T>::OneDArray(const int len)
    {
        Init(len);
    }

    template <class T>
    OneDArray<T>::OneDArray(const Range& r)
    {
        Init(r);
    }

    template <class T>
    OneDArray<T>::OneDArray(const OneDArray<T>& cpy)
    {
        m_first = cpy.m_first;
        m_last = cpy.m_last;
        m_length = m_last - m_first + 1;

        if (m_first==0)
            Init(m_length);
        else
            Init(Range(m_first , m_last));

        memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) );
    }

    template <class T>
    OneDArray<T>& OneDArray<T>::operator=(const OneDArray<T>& rhs)
    {
        if (&rhs != this)
        {
            FreePtr();
            m_first = rhs.m_first;
            m_last = rhs.m_last;
            m_length = rhs.m_length;

            if (m_first == 0)
                Init(m_length);
            else
                Init(Range(m_first , m_last));

            memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) );

        }
        return *this;
    }

    template <class T> 
    void OneDArray<T>::Resize(int l)
    {    
        FreePtr();
        Init(l);
    }

    //private member functions//

    template <class T>
    void OneDArray<T>::Init(const int len)
    {
        Range r(0 , len-1);

        Init(r);

    }        

    template <class T>
    void OneDArray<T>::Init(const Range& r)
    {

        m_first = r.First();
        m_last = r.Last();
        m_length = m_last - m_first + 1; 

        if ( m_length>0 ) 
        {
            m_ptr = new T[ m_length ];
        }
        else 
        {
            m_length = 0;
            m_first = 0;
            m_last = -1;
        }
    }

    template <class T>
    void OneDArray<T>::FreePtr()
    {
        if ( m_length>0 )
            delete[] m_ptr;
    }


    //Two-Dimensional Array type//


    template <class T> class TwoDArray
    {
        typedef T* element_type;

    public:


        TwoDArray(){ Init(0,0); }


        TwoDArray( const int height , const int width ){Init(height , width);}


        TwoDArray( const int height , const int width , T val);


        virtual ~TwoDArray(){
            FreeData();    
        }


        TwoDArray(const TwoDArray<T>& Cpy);


        TwoDArray<T>& operator=(const TwoDArray<T>& rhs);

        void Resize(const int height, const int width);    


        inline element_type& operator[](const int pos){return m_array_of_rows[pos];}


        inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];}

        const int LengthX() const { return m_length_x; }

        const int LengthY() const { return m_length_y; }

        const int FirstX() const { return m_first_x; } 

        const int FirstY() const { return m_first_y; } 

        const int LastX() const { return m_last_x; } 

        const int LastY() const { return m_last_y; }

    private:
        void Init(const int height,const int width);

        void FreeData();    

        int m_first_x;
        int m_first_y;

        int m_last_x;
        int m_last_y;

        int m_length_x;
        int m_length_y;

        element_type* m_array_of_rows;
    };

    //public member functions//

    template <class T>
    TwoDArray<T>::TwoDArray( const int height , const int width , const T val)
    {
        Init( height , width );  
        for (int j=0 ; j<m_length_y ; ++j)
            std::fill_n( m_array_of_rows[j] , m_length_x , val);
    }  

    template <class T>
    TwoDArray<T>::TwoDArray(const TwoDArray<T>& Cpy)
    {
        m_first_x = Cpy.m_first_x;
        m_first_y = Cpy.m_first_y;        
        m_last_x = Cpy.m_last_x;
        m_last_y = Cpy.m_last_y;

        m_length_x = m_last_x - m_first_x + 1;
        m_length_y = m_last_y - m_first_y + 1;        

        if (m_first_x == 0 && m_first_y == 0)        
            Init(m_length_y , m_length_x);
        else{
                //based 2D arrays not yet supported    
        }
        for (int j=0 ; j<m_length_y ; ++j) 
            memcpy( m_array_of_rows[j] , (Cpy.m_array_of_rows)[j] , m_length_x * sizeof( T ) ); 

    }

    template <class T>
    TwoDArray<T>& TwoDArray<T>::operator=(const TwoDArray<T>& rhs)
    {
        if (&rhs != this)
        {
            FreeData();

            m_first_x = rhs.m_first_x;
            m_first_y = rhs.m_first_y;            

            m_last_x = rhs.m_last_x;
            m_last_y = rhs.m_last_y;

            m_length_x = m_last_x - m_first_x + 1;
            m_length_y = m_last_y - m_first_y + 1;        

            if (m_first_x == 0 && m_first_y == 0)
                Init(m_length_y , m_length_x);
            else
            {
                    //based 2D arrays not yet supported
            }

            for ( int j=0 ; j<m_length_y; ++j)
                memcpy( m_array_of_rows[j] , (rhs.m_array_of_rows)[j] , m_length_x * sizeof( T ) ); 

        }

        return *this;

    }

    template <class T>
    void TwoDArray<T>::Resize(const int height, const int width)
    {
        FreeData();
        Init(height , width);
    }

    //private member functions//

    template <class T>
    void TwoDArray<T>::Init(const int height , const int width)
    {
        m_length_x = width; 
        m_length_y = height;
        m_first_x = 0;
        m_first_y = 0;

        m_last_x = m_length_x-1;
        m_last_y = m_length_y-1;

        if (m_length_y>0)
        {
            // allocate the array containing ptrs to all the rows
            m_array_of_rows = new element_type[ m_length_y ];

            if ( m_length_x>0 )
            {
                // next, allocate all the rows
                for (int j=0 ; j<m_length_y ; ++j)
                {
                    m_array_of_rows[j] = new T[ m_length_x ];
                }// j
            }
            else
            {
                m_length_x = 0;
                m_first_x = 0;
                m_last_x = -1;
            }
        }
        else 
        {
            m_length_x = 0;
            m_length_y = 0;
            m_first_x = 0;
            m_first_y = 0;
            m_last_x = -1;
            m_last_y = -1;
        }
    }

    template <class T>
    void TwoDArray<T>::FreeData()
    {
        if (m_length_y>0)
        {
            if (m_length_x>0) 
            {
                // deallocate each row
                for (int j=0 ; j<m_length_y ; ++j)
                {
                    delete[]  m_array_of_rows[j];                
                }// j
            }

            // deallocate the array of rows
            delete[] m_array_of_rows;
        }    
    }

    // Related functions

    template <class T >
    std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array)
    {
        for (int j=0 ; j<array.LengthY() ; ++j)
        {
            for (int i=0 ; i<array.LengthX() ; ++i)
            {
                stream << array[j][i] << " ";
            }// i
            stream << std::endl;
        }// j

        return stream;
    }

    template <class T >
    std::istream & operator>> (std::istream & stream, TwoDArray<T> & array)
    {
        for (int j=0 ; j<array.LengthY() ; ++j)
        {
            for (int i=0 ; i<array.LengthX() ; ++i)
            {
                stream >> array[j][i];
            }// i
        }// j

        return stream;
    }

} //namespace dirac
#endif

---