array1d.h

#ifndef __SEAL_ARRAY_1D_H__
#define __SEAL_ARRAY_1D_H__

#include "collection.h"
#include "randaccess.h"
#include "dataptr.h"
#include "exception.h"

namespace seal
{

template <typename T>
class Array1D : public Collection<T>, public RandomAccess<T>
{
public:

class Iterator : public AbstractIterator<T>
{

friend class Array1D<T>;

public:
    Iterator(void) : AbstractIterator<T>(), _iterIndex(-1), _size(0) {}

    virtual T next(void) throw (OutOfBoundsException);

    virtual bool hasNext(void);

    virtual void reset(void);

private:
    
    Iterator(unsigned int size, T *dataPtr) 
           : AbstractIterator<T>(), _iterIndex(-1), _size(size), _dataPtr(dataPtr)
    {}

    int _iterIndex;
    unsigned int _size;
    
    T *_dataPtr;
}; // class Array1DIterator

public:
    Array1D(void);

    Array1D(unsigned int length);

    Array1D(const Array1D<T> &v);

    virtual ~Array1D();

    virtual unsigned int size(void) const { return *_sizePtr; }

    virtual AbstractIterator<T>* iteratorPtr(void) const 
    { return (new typename Array1D::Iterator(*_sizePtr, _dataPtr->data)); }

    typename Array1D<T>::Iterator iterator(void) const 
    { return typename Array1D::Iterator(*_sizePtr, _dataPtr->data); }

    virtual void purge(void) 
    {
        delete [] _dataPtr->data;
        _dataPtr->data = NULL;
        *_sizePtr = 0;
    }

    virtual bool isEmpty(void) const 
    {
        if (*_sizePtr == 0)
            return true;
        else
            return false;
    }

    inline virtual const T& operator[](int index) const throw (OutOfRangeException<int>);

    inline virtual T& operator[](int index) throw (OutOfRangeException<int>);

    void operator=(const Array1D<T> &v);

    virtual T& first(void) throw (EmptyCollectionException);

    virtual const T& first(void) const throw (EmptyCollectionException);

    virtual T& last(void) throw (EmptyCollectionException);

    virtual const T& last(void) const throw (EmptyCollectionException);

private:
    unsigned int *_refCountPtr;
    unsigned int *_sizePtr;
    DataPtr<T> *_dataPtr;
}; // class Array1D




template <typename T>
Array1D<T>::Array1D(void)
          : Collection<T>(), RandomAccess<T>()
{
    _sizePtr = new unsigned int; *_sizePtr = 0;
    _refCountPtr = new unsigned int; *_refCountPtr = 1;

    _dataPtr = new DataPtr<T>();
    _dataPtr->data = new T [0];
} // Array1D default constructor.

template <typename T>
Array1D<T>::Array1D(unsigned int length)
          : Collection<T>(), RandomAccess<T>()
{
    _sizePtr = new unsigned int; *_sizePtr = length;
    _refCountPtr = new unsigned int; *_refCountPtr = 1;

    _dataPtr = new DataPtr<T>();
    _dataPtr->data = new T [length];
} // Array1D constructor.

template <typename T>
Array1D<T>::Array1D(const Array1D<T> &v)
          : Collection<T>(), RandomAccess<T>(),
            _refCountPtr(v._refCountPtr),
            _sizePtr(v._sizePtr),
            _dataPtr(v._dataPtr)
{
    (*_refCountPtr)++;
} // Array1D copy constructor.

template <typename T>
Array1D<T>::~Array1D()
{
    if (*_refCountPtr <= 1)
    {
        delete _sizePtr;
        delete _refCountPtr;

        delete [] _dataPtr->data;
        delete _dataPtr;
    }
    else
        (*_refCountPtr)--;
} // Array1D destructor.

template <typename T>
const T& Array1D<T>::operator[](int index) const throw (OutOfRangeException<int>)
{
    if (*_sizePtr == 0)
        throw OutOfRangeException<int>(-1, -1, 0);
    else if (index < 0 || index >= *_sizePtr)
        throw OutOfRangeException<int>(0, *_sizePtr-1, index);
    else
        return _dataPtr->data[index];
} // Array1D::operator[] const

template <typename T>
T& Array1D<T>::operator[](int index) throw (OutOfRangeException<int>)
{
    if (*_sizePtr == 0)
        throw OutOfRangeException<int>(-1, -1, 0);
    else if (index < 0 || index >= *_sizePtr)
        throw OutOfRangeException<int>(0, *_sizePtr-1, index);
    else
        return _dataPtr->data[index];
} // Array1D::operator[] 

template <typename T>
void Array1D<T>::operator=(const Array1D<T> &v)
{
    if (_refCountPtr == v._refCountPtr)
        return;

    if (*_refCountPtr > 1)
    {
        (*_refCountPtr)--;
        
        _refCountPtr = v._refCountPtr;
        _sizePtr     = v._sizePtr;
        _dataPtr     = v._dataPtr;

        (*_refCountPtr)++;
    }
    else
    {
        delete _refCountPtr;
        delete _sizePtr;
        delete [] _dataPtr;

        _refCountPtr = v._refCountPtr;
        _sizePtr     = v._sizePtr;
        _dataPtr     = v._dataPtr;

        (*_refCountPtr)++;
    }
} // Array1D::operator=

template <typename T>
T& Array1D<T>::first(void) throw (EmptyCollectionException)
{
    if (*_sizePtr == 0)
        throw EmptyCollectionException();

    return _dataPtr->data[0];
}

template <typename T>
const T& Array1D<T>::first(void) const throw (EmptyCollectionException)
{
    if (*_sizePtr == 0)
        throw EmptyCollectionException();

    return _dataPtr->data[0];
}

template <typename T>
T& Array1D<T>::last(void) throw (EmptyCollectionException)
{
    if (*_sizePtr == 0)
        throw EmptyCollectionException();

    return _dataPtr->data[*_sizePtr-1];
}

template <typename T>
const T& Array1D<T>::last(void) const throw (EmptyCollectionException)
{
    if (*_sizePtr == 0)
        throw EmptyCollectionException();

    return _dataPtr->data[*_sizePtr-1];
}


template <typename T>
bool Array1D<T>::Iterator::hasNext()
{
    if (_size > 0 && _iterIndex < static_cast<int>(_size-1) && _iterIndex >= -1)
        return true;
    else
        return false;
} // Array1DIterator::hasNext()

template <typename T>
T Array1D<T>::Iterator::next() throw (OutOfBoundsException)
{
    if (_size > 0 && _iterIndex < static_cast<int>(_size-1) && _iterIndex >= -1)
    {
        _iterIndex++;
        return _dataPtr[_iterIndex];
    }
    else
        throw OutOfBoundsException();
} // Array1DIterator::next()

template <typename T>
void Array1D<T>::Iterator::reset()
{
    _iterIndex = -1;
} // Array1DIterator::reset

} // End of namespace seal.

#endif // __SEAL_ARRAY_1D_H__

---