DesignPatterns_Iterator

/////////////////////////////////////////////////////////////////////////////////////////
// Iterator
// - Provide a way to access the elements of an aggregate object sequentially without
//   exposing its underlying representation.
//
// Author     : ZAsia
// Date       : 15/05/14
// Warning    : In practice, declaration and implementation should
//              be separated(.h and .cpp).
/////////////////////////////////////////////////////////////////////////////////////////
#include 
using namespace std;

#define DEFAULT_CAPACITY 128

// Iterator
// - defines an interface for accessing and traversing elements.
template 
class Iterator
{
public:
	virtual void First() = 0;
	virtual void Next() = 0;
	virtual bool IsDone() const = 0;
	virtual Item CurrentItem() const = 0;
};

// forward declaration
template 
class ConcreteAggregate;

// ConcreteIterator
// - implements the Iterator interface.
// - keep the track of the current position in the traversal of the aggregate.
//////////
// - the implementation of ReverseIterator is identical, except its First operation
//   positions _current to the end of the ConcreteAggregate, and Next decrements 
//   _current toward the first item.
template 
class ConcreteIterator : public Iterator
{
public:
	ConcreteIterator(const ConcreteAggregate *aggr) : 
		_aggr(aggr), _current(0) { }

	// First positions the iterator to the first element.
	virtual void First()
	{
		_current = 0;
	}

	// Next advances the current element.
	virtual void Next()
	{
		if (_current < _aggr->Count())
		{
			++_current;
		}
	}

	// IsDone checks whether the index refers to an element within the List.
	virtual bool IsDone() const
	{
		return _current >= _aggr->Count();
	}

	// CurrentItem returns the item at the current index.
	// If the iteration has already terminated, then throw an exception.
	virtual Item CurrentItem() const
	{
		if (IsDone())
		{
			cout << "Iterator out of bounds." << endl;
			return 0;
		}
		return _aggr->Get(_current);
	}

private:
	const ConcreteAggregate *_aggr;
	long _current;
};

// Aggregate
// - defines an interface for creating an Iterator object.
template 
class Aggregate
{
public:
	Aggregate( ) { }
	virtual ~Aggregate() { }
	virtual ConcreteIterator *CreateIterator() = 0;
	virtual void Append(Item item) = 0;
	virtual void Remove(Item item) = 0;
	virtual long Count() const = 0;
	virtual Item Get(long index) const = 0;
};

// ConcreteAggregate
// - implements the Iterator creation interface to return an instance of the
//   proper ConcreteIterator.
template
class ConcreteAggregate : public Aggregate
{
public:
	ConcreteAggregate() : _size(0), _iter(nullptr) { }

	virtual ConcreteIterator *CreateIterator()
	{
		if (_iter)
		{
			return _iter;
		}
		return new ConcreteIterator(this);
	}

	virtual void Append(Item item)
	{
		if (_size > DEFAULT_CAPACITY)
		{
			cout << "Aggregate out of capacity." << endl;
			return;
		}
		_arr[_size++] = item;
	}

	virtual void Remove(Item item)
	{
		if (_size == 0)
		{
			return;
		}
		for (int i = 0; i < _size; ++i)
		{
			if (_arr[i] == item)
			{
				for (int j = i; j < _size - 1; ++j)
				{
					_arr[j] = _arr[j + 1];
				}
				--_size;
			}
		}
	}

	virtual long Count() const
	{
		return _size;
	}

	virtual Item Get(long index) const
	{
		return _arr[index];
	}

private:
	ConcreteIterator *_iter;
	long _size;
	Item _arr[DEFAULT_CAPACITY];
};

// Collaborations
// - A ConcreteIterator keeps track of the current object in the aggregate and
//   can compute the succeeding object in the traversal.
int main()
{
	ConcreteAggregate  aggregate;
	for (long item = 0; item < 21; ++item)
	{
		aggregate.Append(item);
	}

	aggregate.Remove(15);

	ConcreteIterator *pIterator = aggregate.CreateIterator();

	for (pIterator->First(); !pIterator->IsDone(); pIterator->Next())
	{
		cout << pIterator->CurrentItem() << endl;
	}

	if (pIterator)
	{
		delete pIterator;
		pIterator = nullptr;
	}

	return 0;
}

///////////////////////////////////////////////////////////////////////////////////
// 1. How robust is the iterator? It can be dangerous to modify an aggregate while
//    you'r traversing it. A robust iterator most rely on registering the iterator
//    with the aggregate. On insertion or removal, the aggregate either adjusts the
//    internal state of iterators it has produced, or it maintains information 
//    internally to ensure proper traversal.
// 2. Polymorphic iterators have another drawback: the client is responsible for
//    deleting them. This is error-prone, because it's easy to forget to free a
//    heap-allocated when you're finished with it. And if an exception is triggered,
//    the iterator object will never be freed.

// 1. Making sure iterators get deleted. Notice that CreateIterator returns a 
// newly allocated iterator object. We're responsible for deleting it. If
// we forget, then we've created storage leak. To make life easier for client,
// we'll provide an IteratorPtr that acts as a proxy for an iterator. It takes
// care of cleaning up the Iterator object when it goes out of scope.
// 2. IteratorPtr is always allocated on the stack. C++ automatically takes care
// of calling its destructor, which deletes the real iterator. 

/////////////////////////////////////////////////////////////////////////////////////////
// Iterator
// - Provide a way to access the elements of an aggregate object sequentially without
//   exposing its underlying representation.
//
// Author     : ZAsia
// Date       : 15/05/14
// Warning    : In practice, declaration and implementation should
//              be separated(.h and .cpp).
/////////////////////////////////////////////////////////////////////////////////////////
#include 
using namespace std;

#define DEFAULT_CAPACITY 128

// Iterator
// - defines an interface for accessing and traversing elements.
template 
class Iterator
{
public:
	virtual void First() = 0;
	virtual void Next() = 0;
	virtual bool IsDone() const = 0;
	virtual Item CurrentItem() const = 0;
};

// forward declaration
template 
class ConcreteAggregate;

// ConcreteIterator
// - implements the Iterator interface.
// - keep the track of the current position in the traversal of the aggregate.
//////////
// - the implementation of ReverseIterator is identical, except its First operation
//   positions _current to the end of the ConcreteAggregate, and Next decrements 
//   _current toward the first item.
template 
class ConcreteIterator : public Iterator
{
public:
	ConcreteIterator(const ConcreteAggregate *aggr) : 
		_aggr(aggr), _current(0) { }

	// First positions the iterator to the first element.
	virtual void First()
	{
		_current = 0;
	}

	// Next advances the current element.
	virtual void Next()
	{
		if (_current < _aggr->Count())
		{
			++_current;
		}
	}

	// IsDone checks whether the index refers to an element within the List.
	virtual bool IsDone() const
	{
		return _current >= _aggr->Count();
	}

	// CurrentItem returns the item at the current index.
	// If the iteration has already terminated, then throw an exception.
	virtual Item CurrentItem() const
	{
		if (IsDone())
		{
			cout << "Iterator out of bounds." << endl;
			return 0;
		}
		return _aggr->Get(_current);
	}

private:
	const ConcreteAggregate *_aggr;
	long _current;
};

// Aggregate
// - defines an interface for creating an Iterator object.
template 
class Aggregate
{
public:
	Aggregate( ) { }
	virtual ~Aggregate() { }
	virtual ConcreteIterator *CreateIterator() = 0;
	virtual void Append(Item item) = 0;
	virtual void Remove(Item item) = 0;
	virtual long Count() const = 0;
	virtual Item Get(long index) const = 0;
};

// ConcreteAggregate
// - implements the Iterator creation interface to return an instance of the
//   proper ConcreteIterator.
template
class ConcreteAggregate : public Aggregate
{
public:
	ConcreteAggregate() : _size(0), _iter(nullptr) { }

	virtual ConcreteIterator *CreateIterator()
	{
		if (_iter)
		{
			return _iter;
		}
		return new ConcreteIterator(this);
	}

	virtual void Append(Item item)
	{
		if (_size > DEFAULT_CAPACITY)
		{
			cout << "Aggregate out of capacity." << endl;
			return;
		}
		_arr[_size++] = item;
	}

	virtual void Remove(Item item)
	{
		if (_size == 0)
		{
			return;
		}
		for (int i = 0; i < _size; ++i)
		{
			if (_arr[i] == item)
			{
				for (int j = i; j < _size - 1; ++j)
				{
					_arr[j] = _arr[j + 1];
				}
				--_size;
			}
		}
	}

	virtual long Count() const
	{
		return _size;
	}

	virtual Item Get(long index) const
	{
		return _arr[index];
	}

private:
	ConcreteIterator *_iter;
	long _size;
	Item _arr[DEFAULT_CAPACITY];
};

// IteratorPtr
// 1. Making sure iterators get deleted. Notice that CreateIterator returns a 
// newly allocated iterator object. We're responsible for deleting it. If
// we forget, then we've created storage leak. To make life easier for client,
// we'll provide an IteratorPtr that acts as a proxy for an iterator. It takes
// care of cleaning up the Iterator object when it goes out of scope.
// 2. IteratorPtr is always allocated on the stack. C++ automatically takes care
// of calling its destructor, which deletes the real iterator. 
template 
class IteratorPtr
{
public:
	IteratorPtr(Iterator *i) : _i(i) { }
	~IteratorPtr() { delete _i; }
	
	Iterator *operator->() { return _i; }
	Iterator &operator*() { return *_i; }

private:
	// disallow copy and assignment to avoid multiple deletions of _i
	IteratorPtr(const IteratorPtr &ip) { }
	IteratorPtr &operator=(const IteratorPtr &rs) { }

private:
	Iterator *_i;
};

// Collaborations
// - A ConcreteIterator keeps track of the current object in the aggregate and
//   can compute the succeeding object in the traversal.
int main()
{
	ConcreteAggregate  aggregate;
	for (long item = 0; item < 21; ++item)
	{
		aggregate.Append(item);
	}

	aggregate.Remove(15);

//	ConcreteIterator *pIterator = aggregate.CreateIterator();
	IteratorPtr iterator(aggregate.CreateIterator());

	for (iterator->First(); !iterator->IsDone(); iterator->Next())
	{
		cout << iterator->CurrentItem() << endl;
	}

//	if (pIterator)
//	{
///		delete pIterator;
//		pIterator = nullptr;
//	}

	return 0;
}

///////////////////////////////////////////////////////////////////////////////////
// 1. How robust is the iterator? It can be dangerous to modify an aggregate while
//    you'r traversing it. A robust iterator most rely on registering the iterator
//    with the aggregate. On insertion or removal, the aggregate either adjusts the
//    internal state of iterators it has produced, or it maintains information 
//    internally to ensure proper traversal.
// 2. Polymorphic iterators have another drawback: the client is responsible for
//    deleting them. This is error-prone, because it's easy to forget to free a
//    heap-allocated when you're finished with it. And if an exception is triggered,
//    the iterator object will never be freed.