cellarray.h

#ifndef __SEAL_CELL_ARRAY_H__
#define __SEAL_CELL_ARRAY_H__

#include "exception.h"
#include "array1d.h"
#include <sstream>
#include <iostream>

namespace seal
{

template <typename DataType>
class Cell;

template <typename DataType>
class CellArray;

template <typename DataType>
std::ostream& operator<<(std::ostream& ostr, seal::Cell<DataType> &c);

template <typename DataType>
class Cell
{

friend class CellArray<DataType>;

template <typename type>
friend std::ostream& operator<<(std::ostream& ostr, seal::Cell<type> &c);

public:

    Cell(void);

    Cell(const Cell &cell);

    ~Cell();

    void operator=(const DataType &val);

    void operator=(const Cell<DataType> &rhs);

private:
    DataType *_dataPtr;
    unsigned int *_refCountPtr;
}; // class Cell

template <typename DataType>
Cell<DataType>::Cell(void)
{
    _refCountPtr = new unsigned int; *_refCountPtr = 1;
    _dataPtr = new DataType;
}

template <typename DataType>
Cell<DataType>::Cell(const Cell<DataType> &bit)
    : _dataPtr(bit._dataPtr), _refCountPtr(bit._refCountPtr)
{
    (*_refCountPtr)++;
}

template <typename DataType>
Cell<DataType>::~Cell()
{
    if (*_refCountPtr > 1)
        (*_refCountPtr)--;
    else
    {
        delete _refCountPtr;
        delete _dataPtr;
    }
}

template <typename DataType>
void Cell<DataType>::operator=(const DataType &val)
{
    *_dataPtr = val;
}

template <typename DataType>
void Cell<DataType>::operator=(const Cell<DataType> &bit)
{
    if (_refCountPtr == bit._refCountPtr)
        return;

    if (*_refCountPtr > 1)
    {
        (*_refCountPtr)--;

        _refCountPtr = bit._refCountPtr;
        _dataPtr = bit._dataPtr;

        (*_refCountPtr)++;
    }
    else
    {
        delete _refCountPtr;
        delete _dataPtr;

        _refCountPtr = bit._refCountPtr;
        _dataPtr = bit._dataPtr;

        (*_refCountPtr)++;
    }
}


template <typename DataType>
class CellArray : public Array1D< Cell<DataType> >
{
public:
    CellArray(unsigned int size) : Array1D< Cell<DataType> >(size) {}

    CellArray(const CellArray<DataType> &a) : Array1D< Cell<DataType> >(a) {}

    CellArray<DataType> operator()(int lower, int upper) throw (OutOfRangeException<int>);

    const CellArray<DataType> operator()(int lower, int upper) const throw (OutOfRangeException<int>);

    CellArray<DataType> operator,(const CellArray<DataType> &a);

}; // class CellArray

template <typename DataType>
CellArray<DataType> CellArray<DataType>::operator()(int lower, int upper) throw (OutOfRangeException<int>)
{
    unsigned int size = Array1D< Cell<DataType> >::size();
    if (lower < 0 || lower > size-1)
        throw OutOfRangeException<int>(0, size-1, lower);
    if (upper < 0 || upper > size-1)
        throw OutOfRangeException<int>(0, size-1, lower);

    CellArray<DataType> newArray(upper-lower+1);
    for (int i = lower; i <= upper; i++)
        newArray[i-lower] = Array1D< Cell<DataType> >::operator[](i);

    return newArray;
}

template <typename DataType>
const CellArray<DataType> CellArray<DataType>::operator()(int lower, int upper) const throw (OutOfRangeException<int>)
{
    unsigned int size = Array1D< Cell<DataType> >::size();
    if (lower < 0 || lower > size-1)
        throw OutOfRangeException<int>(0, size-1, lower);
    if (upper < 0 || upper > size-1)
        throw OutOfRangeException<int>(0, size-1, lower);

    CellArray<DataType> newArray(upper-lower+1);
    for (int i = lower; i <= upper; i++)
        newArray[i-lower] = Array1D< Cell<DataType> >::operator[](i);

    return newArray;
}

template <typename DataType>
CellArray<DataType> CellArray<DataType>::operator,(const CellArray<DataType> &a)
{
    unsigned int os = Array1D< Cell<DataType> >::size(), ns = os + a.size();
    CellArray<DataType> na(ns);

    for (int i = 0; i < os; i++)
    {
        *(na[i]._dataPtr) = *(Array1D< Cell<DataType> >::operator[](i)._dataPtr);
    }

    for (int i = 0; i < a.size(); i++)
    {
        *(na[i+os]._dataPtr) = *(a[i]._dataPtr);
    }

    return na;
}

template <typename DataType>
std::ostream& operator<<(std::ostream& ostr, seal::Cell<DataType> &c)
{
    std::cout << *(c._dataPtr);
    return std::cout;
}

} // End of namespace seal

#endif // __SEAL_CELL_ARRAY_H__

---