Array.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

namespace Imagine {


    template <typename T> class Array {
    private:
        int* _count;    // pointer to reference counter
        T *_data;       // pointer to data
        size_t _size;   // size of array
        // Allocates memory
        void alloc(size_t size,T* ptr=0,bool handleDelete=false) 
        {
            _size=size;
            if (!ptr) {
                if (size > 0)
                {
                    _data= new T[size];
                    _count=new int(1);
                }
                else
                {
                    _data = 0;
                    _count = 0;
                }
            }
            else {
                _data=ptr;
                _count= (handleDelete? new int(1): 0);
            }
        }
        // Frees memory unless reference counter indicates other users
        void kill()
        {
            if (!_count)
                return;
            (*_count)--;
            if (!(*_count)) {
                delete _count;
                delete[] _data;
                _data = 0;
                _count = 0;
                _size = 0;
            }
        }
        // Declares myself as a new user
        void copy(const Array& A)
        {
            _count=A._count;
            _data=A._data;
            _size=A._size;
            if(_count)
                (*_count)++;
        }
    public:
        typedef T* iterator;
        typedef const T* const_iterator;

        Array(): _count(0), _data(0), _size(0) {}
        explicit Array(size_t size) { alloc(size); }
        Array(T* ptr, size_t size,bool handleDelete=false) { alloc(size,ptr,handleDelete); }
        explicit Array(const Array& A) { copy(A); }
        template <typename T2> Array(const Array<T2>& A) {
            alloc(A.size());
            for (size_t i=0;i<A.size();i++) _data[i] = T(A[i]) ;
        }
        Array(const std::list<T>& L) {
            alloc(L.size());
            size_t i=0;
            for (typename std::list<T>::const_iterator it=L.begin();it!=L.end();++it,++i)
                (*this)[i]= *it;
        }
        virtual ~Array() { kill(); }
        void setSize(size_t size) {
            if (size==_size) return;
            kill(); alloc(size);
        }
        Array& operator = (const Array& A) { kill(); copy(A); return *this; }
        template <typename T2> Array& operator = (const Array<T2>& A) {
            kill();
            alloc(A.size());
            for (size_t i=0;i<A.size();i++) _data[i] = T( A[i] );
            return *this;
        }
        Array clone() const {
            Array A(_size);
            std::copy( begin(), end(), A.begin() );
            return A;
        }
        bool empty() const { return (_size==0); }
        size_t size() const { return _size; }
        const T& operator[](size_t i) const { assert(i<_size);return _data[i]; }
        T& operator[](size_t i) { assert(i<_size); return _data[i];  }
        T* data() { return _data; }
        const T* data() const { return _data; }
        iterator begin() { return _data; }
        const_iterator begin() const { return _data; }
        iterator end() { return _data+_size; }
        const_iterator end() const { return _data+_size; }
        
        Array getSubArray(size_t offset, size_t size) const {
            Array A(size);
            for (size_t i=0;i<A.size();i++) {
                A[i] = (*this)[i+offset];
            }
            return A;
        }
        Array& fill(const T& x) {
            std::fill(begin(),end(),x);
            return *this;
        }
        bool operator == (const Array& A) const {
            if (A.size() != size()) return false;
            for (size_t i=0;i<size();i++)
                if (!(_data[i] == A[i]))
                    return false;
            return true;
        }
        bool operator != (const Array& A) const {
            return !(*this == A);
        }
        friend std::pair<T,T> range(const Array& A) {   
            const_iterator it = A.begin();
            std::pair<T,T> r(*it,*it);
            for ( ++it; it != A.end() ; ++it) {
                r.first=std::min(r.first,*it);
                r.second=std::max(r.second,*it);
            }
            return r;
        }
        friend std::pair<T,T> prange(const Array& A) {  
            const_iterator it = A.begin();
            std::pair<T,T> r(*it,*it);
            for ( ++it; it != A.end() ; ++it) {
                r.first=pmin(r.first,*it);
                r.second=pmax(r.second,*it);
            }
            return r;
        }
        friend void write(std::ostream& out,const Array& A) {
            size_t n = A._size;
            out.write((const char*)&n,sizeof(size_t));
            out.write((const char*)A._data,(std::streamsize)A._size*sizeof(T));
        }
        friend void read(std::istream& in,Array& A) {
            size_t n;
            in.read((char*)&n,sizeof(size_t));
            A.setSize(n);
            in.read((char*)A._data,(std::streamsize)A._size*sizeof(T));
        }
        friend inline std::ostream& operator<<(std::ostream& out,const Array& A) {
            out<<A.size()<<" ";
            for (size_t i=0;i<A.size();i++) {
                out<<A[i];
                if (i<A.size()-1) out<<" ";
            }
            return out;
        }
        friend inline std::istream& operator>>(std::istream& in,Array& A) {
            size_t n;
            in>>n;
            A.setSize(n);
            for (size_t i=0;i<A.size();i++) 
                in>>A[i];
            return in;
        }
    };


}