#ifndef _SHIPYARDITERATOR_HPP_
#define _SHIPYARDITERATOR_HPP_

#include <vector>

#include "PersistedState.hpp"
#include "Shipyard.hpp"


class SkybladeInfo
{
private:
	const Shipyard::Skyblade* m_unpurchased;
	PurchasedShip* m_purchased;

public:
	SkybladeInfo( const Shipyard::Skyblade* unpurchased, PurchasedShip* purchased ) :
		m_unpurchased( unpurchased ),
		m_purchased( purchased )
	{
	}

	friend class Obsoletes;
};

class SkybladeWeaponInfo
{
};


namespace do_not_touch
{
	template< typename t_type >
	class ShipyardIterator
	{
	public:
		enum ClampType
		{
			CLAMP,
			LOOP
		};

	private:
		t_type& m_inventory;
		typename t_type::iterator m_current;
		ClampType m_clampType;

		void AdvanceIterator( typename t_type::iterator& iter, int step )
		{
			// @TODO - RCD
			// Only supports steps of 1 or -1 at the moment
			if( step == 1 || step == -1 )
			{
				switch( m_clampType )
				{
				case CLAMP:
					{
						if( step == 1 )
						{
							if( iter != m_inventory.end() )
							{
								t_type::iterator temp = iter;
								++temp;

								if( temp != m_inventory.end() )
								{
									iter = temp;
								}
							}
						}
						else
						{
							if( iter != m_inventory.begin() )
							{
								--iter;
							}
						}

						break;
					}

					// @TODO - RCD
					// Implement looping
				case LOOP:
					{
						break;
					}
				}
			}
		}

	public:
		ShipyardIterator( t_type& inventory ) :
			m_inventory( inventory ),
			m_clampType( CLAMP )
		{
			m_current = inventory.begin();
		}

		ShipyardIterator( t_type& inventory, typename t_type::iterator& current ) :
			m_inventory( inventory ),
			m_current( current ),
			m_clampType( CLAMP )
		{
		}

		inline void SetClampType( ClampType type )
		{
			m_clampType = type;
		}

		inline typename t_type::value_type& operator*()
		{
			return *m_current;
		}

		inline typename t_type::value_type* operator->()
		{
			return &(*m_current);
		}

		inline const typename t_type::value_type* operator->() const
		{
			return &(*m_current);
		}

		inline ShipyardIterator< t_type >& operator++()
		{
			AdvanceIterator( m_current, 1 );
			return *this;
		}

		inline ShipyardIterator< t_type >& operator--()
		{
			AdvanceIterator( m_current, -1 );
			return *this;
		}
	};
}

typedef std::vector< SkybladeInfo > SkybladeInventory;
typedef std::vector< SkybladeWeaponInfo > SkybladeWeaponInventory;
typedef do_not_touch::ShipyardIterator< SkybladeInventory > SkybladeIterator;
typedef do_not_touch::ShipyardIterator< SkybladeWeaponInventory > SkybladeWeaponIterator;

#endif // _SHIPYARDITERATOR_HPP_

	template< typename t_type >
	class ShipyardIterator
	{
	public:
		enum ClampType	{ CLAMP, LOOP };

	private:
		t_type& m_inventory;
		typename t_type::iterator m_current;

		// *SNIP*
	};

quote:

---

Originally posted by feline

I am seeing odd colouring here, but to be honest I am confused by this code. Just taking a small piece, specifically:

	template< typename t_type >
	class ShipyardIterator
	{
	public:
		enum ClampType	{ CLAMP, LOOP };

	private:
		t_type& m_inventory;
		typename t_type::iterator m_current;

		// *SNIP*
	};

I have reformatted the enum to save space.

I do some template programming, but not a vast amount, so perhaps there is simply something I am not familiar with going on here, but why is "typename" used on the "m_current" line?

You are using "::iterator", which has to be defined on the type that is used to instantiate this template class, but I would expect the compiler to enforce this restriction at compile time, if "::iterator" is not valid, e.g. because you used the type "int" the code will simply not compile.

---

template< typename T >
class Foo
{
    T::someTypeDefine m_myVar;
};